map_1.json

Junjie

2023-07-03 586605cbe95aaca03844763b74392ba70644fecc

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

@@ -53,6 +53,8 @@
    @Autowired
    private WrkMastMapper wrkMastMapper;
    @Autowired
    private WrkMastService wrkMastService;
    @Autowired
    private WrkDetlService wrkDetlService;
    @Autowired
    private LocMastService locMastService;
@@ -571,7 +573,7 @@
                    //数据库中也不存在地图数据，从地图文件中获取
                    //载入地图
                    NavigateMapData mapData = new NavigateMapData(i);
                    List<List<MapNode>> lists = mapData.getJsonData(-1, null);//获取完整地图(包括入库出库)
                    List<List<MapNode>> lists = mapData.getJsonData(-1, null, null);//获取完整地图(包括入库出库)

                    //存入数据库
                    basMap = new BasMap();
@@ -671,15 +673,31 @@
                    if (wrkMast != null) {
                        if (wrkMast.getWrkSts() == 4 || wrkMast.getWrkSts() == 8) {
                            ShuttleThread shuttleThread = null;
                            ShuttleProtocol shuttleProtocol = null;
                            HashMap<String, Object> searchIdleShuttle = null;

                            LiftThread liftThread = (LiftThread) SlaveConnection.get(SlaveType.Lift, 1);
                            LiftProtocol liftProtocol = liftThread.getLiftProtocol();

                            if (wrkMast.getWrkSts() == 4) {
                                //寻找最近且空闲的四向穿梭车
                                searchIdleShuttle = this.searchIdleShuttle(wrkMast);
                                shuttleThread = (ShuttleThread) searchIdleShuttle.get("result");
                                if (wrkMast.getShuttleNo() == null) {
                                    //寻找最近且空闲的四向穿梭车
                                    searchIdleShuttle = this.searchIdleShuttle(wrkMast);
                                    shuttleThread = (ShuttleThread) searchIdleShuttle.get("result");
                                    wrkMast.setShuttleNo(shuttleThread.getSlave().getId());//给工作档分配四向穿梭车号
                                    wrkMastMapper.updateById(wrkMast);
                                    shuttleProtocol = shuttleThread.getShuttleProtocol();
                                    if (!shuttleProtocol.isIdle()) {
                                        continue;
                                    }
                                }else {
                                    //直接使用任务保存中的小车
                                    shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, wrkMast.getShuttleNo());
                                    shuttleProtocol = shuttleThread.getShuttleProtocol();
                                    if (!shuttleProtocol.isIdle(workNo)) {
                                        continue;
                                    }
                                }
                            }else if(wrkMast.getWrkSts() == 8){//状态8，需要向小车下发命令从提升机移动出去，需要判断提升机状是否空闲、提升机是否到达目标楼层、目标楼层站点是否存在、目标楼层站点是否给出提升机到位信号
                                //状态8，等待命令进行入库搬运动作

@@ -717,14 +735,17 @@

                                Integer shuttleNo = wrkMast.getShuttleNo();//四向穿梭车号
                                shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, shuttleNo);
                                shuttleProtocol = shuttleThread.getShuttleProtocol();
                                if (!shuttleProtocol.isIdle(workNo)) {
                                    continue;
                                }
                            }

                            if (shuttleThread == null) {
                                continue;
                            }

                            ShuttleProtocol shuttleProtocol = shuttleThread.getShuttleProtocol();
                            if (!shuttleProtocol.isIdle()) {
                            if (shuttleProtocol == null) {
                                continue;
                            }

@@ -749,55 +770,118 @@
                            //提升机口站点库位号
                            String liftSiteLocNo = Utils.levToOutInStaLocNo(currentLev);

                            if (wrkMast.getWrkSts() == 8 || Boolean.parseBoolean(searchIdleShuttle.get("sameLay").toString())) {
                                //同一层直接取货无需经过提升机
                            if (wrkMast.getWrkSts() == 4) {
                                if (currentLev == Utils.getLev(locNo)) {
                                    //小车和目标在同一楼层
                                    //直接计算车到提升机取货再到库位路径指令
                                    List<ShuttleCommand> commands = this.shuttleAssignCommand(wrkMast.getWrkSts() == 4 ? currentLocNo : liftSiteLocNo, liftSiteLocNo, locNo, assignCommand, shuttleThread);
                                    if (commands == null) {
                                        continue;//找不到路径等待下一次
                                    }
                                    assignCommand.setCommands(commands);
                                    //分配目标库位
                                    shuttleProtocol.setLocNo(wrkMast.getLocNo());
                                    //目标库位
                                    assignCommand.setLocNo(wrkMast.getLocNo());
                                    wrkMast.setWrkSts(9L);//小车入库中
                                }else {
                                    //小车和目标不在同一楼层
                                    //小车移动到提升机口，计算路径
                                    List<ShuttleCommand> commands = this.shuttleAssignCommand(currentLocNo, liftSiteLocNo, NavigationMapType.NONE.id, assignCommand, shuttleThread);
                                    if (commands == null) {
                                        continue;//未找到路径
                                    }

                                    //获取当前小车所在楼层的站点信息
                                    BasDevp basDevp = basDevpService.queryByLocNo(liftSiteLocNo);
                                    Short endStartCode = Short.parseShort(basDevp.getQrCodeValue());//站点二维码

                                    //增加移动进提升机命令
                                    ShuttleCommand moveCommand = shuttleThread.getMoveCommand(endStartCode, liftProtocol.getBarcode(), 1400, ShuttleRunDirection.TOP.id, null, null, 500);
                                    commands.add(moveCommand);

                                    //分配目标库位
                                    shuttleProtocol.setLocNo(liftSiteLocNo);
                                    //目标库位
                                    assignCommand.setLocNo(liftSiteLocNo);
                                    assignCommand.setCommands(commands);
                                    wrkMast.setWrkSts(5L);//小车迁移状态
                                }
                            } else if (wrkMast.getWrkSts() == 8) {
                                //直接计算车到提升机取货再到库位路径指令
                                List<ShuttleCommand> commands = this.shuttleAssignCommand(wrkMast.getWrkSts() == 4 ? currentLocNo : liftSiteLocNo, liftSiteLocNo, locNo, assignCommand, shuttleThread);
                                if (commands == null) {
                                    continue;//找不到路径等待下一次
                                }
                                if (wrkMast.getWrkSts() == 8) {
                                    //此时车在提升机内部，下达一步指令让车移动到提升机口
                                    Integer staNo = Utils.levToOutInStaNo(currentLev >= 2 ? currentLev + 1 : currentLev);//站点号
                                    BasDevp basDevp = basDevpService.selectById(staNo);

                                    short startCode = liftProtocol.getBarcode();//提升机内部二维码
                                    Short distCode = Short.parseShort(basDevp.getQrCodeValue());//提升机口站点二维码
                                    Short runDirection = ShuttleRunDirection.BOTTOM.id;//运行方向
                                    //获取命令
                                    ShuttleCommand moveCommand = shuttleThread.getMoveCommand(startCode, distCode, 1400, runDirection, startCode, 1400, 500);
                                    commands.add(0, moveCommand);//将该指令添加到队头
                                }
                                //此时车在提升机内部，下达一步指令让车移动到提升机口
                                Integer staNo = Utils.levToOutInStaNo(currentLev >= 2 ? currentLev + 1 : currentLev);//站点号
                                BasDevp basDevp = basDevpService.selectById(staNo);

                                short startCode = liftProtocol.getBarcode();//提升机内部二维码
                                Short distCode = Short.parseShort(basDevp.getQrCodeValue());//提升机口站点二维码
                                Short runDirection = ShuttleRunDirection.BOTTOM.id;//运行方向
                                //获取命令
                                ShuttleCommand moveCommand = shuttleThread.getMoveCommand(startCode, distCode, 1400, runDirection, null, null, 500);
                                commands.add(0, moveCommand);//将该指令添加到队头

                                assignCommand.setCommands(commands);
                                //分配目标库位
                                shuttleProtocol.setLocNo(wrkMast.getLocNo());
                                //目标库位
                                assignCommand.setLocNo(wrkMast.getLocNo());
                                wrkMast.setWrkSts(9L);//小车入库中
                            }else {
                                //不同层，将目标库位分配成提升机库位号

                                //小车移动到提升机口，计算路径
                                List<ShuttleCommand> commands = this.shuttleAssignCommand(currentLocNo, liftSiteLocNo, NavigationMapType.NONE.id, assignCommand, shuttleThread);
                                if (commands == null) {
                                    continue;//未找到路径
                                }

                                //获取当前小车所在楼层的站点信息
                                BasDevp basDevp = basDevpService.queryByLocNo(liftSiteLocNo);
                                Short endStartCode = Short.parseShort(basDevp.getQrCodeValue());//站点二维码

                                //增加移动进提升机命令
                                ShuttleCommand moveCommand = shuttleThread.getMoveCommand(endStartCode, liftProtocol.getBarcode(), 1400, ShuttleRunDirection.TOP.id, endStartCode, 1400, 500);
                                commands.add(moveCommand);

                                //分配目标库位
                                shuttleProtocol.setLocNo(liftSiteLocNo);
                                //目标库位
                                assignCommand.setLocNo(liftSiteLocNo);
                                assignCommand.setCommands(commands);
                                wrkMast.setWrkSts(5L);//小车迁移状态
                            }

//                            if (wrkMast.getWrkSts() == 8 || Boolean.parseBoolean(searchIdleShuttle.get("sameLay").toString())) {
//                                //同一层直接取货无需经过提升机
//                                //直接计算车到提升机取货再到库位路径指令
//                                List<ShuttleCommand> commands = this.shuttleAssignCommand(wrkMast.getWrkSts() == 4 ? currentLocNo : liftSiteLocNo, liftSiteLocNo, locNo, assignCommand, shuttleThread);
//                                if (commands == null) {
//                                    continue;//找不到路径等待下一次
//                                }
//                                if (wrkMast.getWrkSts() == 8) {
//                                    //此时车在提升机内部，下达一步指令让车移动到提升机口
//                                    Integer staNo = Utils.levToOutInStaNo(currentLev >= 2 ? currentLev + 1 : currentLev);//站点号
//                                    BasDevp basDevp = basDevpService.selectById(staNo);
//
//                                    short startCode = liftProtocol.getBarcode();//提升机内部二维码
//                                    Short distCode = Short.parseShort(basDevp.getQrCodeValue());//提升机口站点二维码
//                                    Short runDirection = ShuttleRunDirection.BOTTOM.id;//运行方向
//                                    //获取命令
//                                    ShuttleCommand moveCommand = shuttleThread.getMoveCommand(startCode, distCode, 1400, runDirection, startCode, 1400, 500);
//                                    commands.add(0, moveCommand);//将该指令添加到队头
//                                }
//                                assignCommand.setCommands(commands);
//                                //分配目标库位
//                                shuttleProtocol.setLocNo(wrkMast.getLocNo());
//                                //目标库位
//                                assignCommand.setLocNo(wrkMast.getLocNo());
//                                wrkMast.setWrkSts(9L);//小车入库中
//                            }else {
//                                //不同层，将目标库位分配成提升机库位号
//
//                                //小车移动到提升机口，计算路径
//                                List<ShuttleCommand> commands = this.shuttleAssignCommand(currentLocNo, liftSiteLocNo, NavigationMapType.NONE.id, assignCommand, shuttleThread);
//                                if (commands == null) {
//                                    continue;//未找到路径
//                                }
//
//                                //获取当前小车所在楼层的站点信息
//                                BasDevp basDevp = basDevpService.queryByLocNo(liftSiteLocNo);
//                                Short endStartCode = Short.parseShort(basDevp.getQrCodeValue());//站点二维码
//
//                                //增加移动进提升机命令
//                                ShuttleCommand moveCommand = shuttleThread.getMoveCommand(endStartCode, liftProtocol.getBarcode(), 1400, ShuttleRunDirection.TOP.id, endStartCode, 1400, 500);
//                                commands.add(moveCommand);
//
//                                //分配目标库位
//                                shuttleProtocol.setLocNo(liftSiteLocNo);
//                                //目标库位
//                                assignCommand.setLocNo(liftSiteLocNo);
//                                assignCommand.setCommands(commands);
//                                wrkMast.setWrkSts(5L);//小车迁移状态
//                            }

                            if (wrkMastMapper.updateById(wrkMast) > 0) {
                                //下发任务
@@ -826,12 +910,14 @@
        }

        //计算小车起点到中点所需命令
        List<NavigateNode> calc = NavigateUtils.calc(startLocNo, locNo, mapType);
        List<NavigateNode> calc = NavigateUtils.calc(startLocNo, locNo, mapType, Utils.getShuttlePoints(shuttleThread.getSlave().getId(), Utils.getLev(startLocNo)));
        List<ShuttleCommand> commands = new ArrayList<>();
        if (calc == null) {
            return null;
        }

        if (!Utils.checkShuttlePath(calc, shuttleThread.getSlave().getId())) {//检测穿梭车行走路径，是否存在其他小车，如有其他小车则进行调离
            return null;
        }
        List<NavigateNode> allNode = new ArrayList<>();
        allNode.addAll(calc);

@@ -841,16 +927,31 @@
        for (ArrayList<NavigateNode> nodes : data) {
            //开始路径
            NavigateNode startPath = nodes.get(0);

            //中间路径
            NavigateNode middlePath = nodes.get(nodes.size() - 2);
            NavigateNode middlePath = null;
            //通过xy坐标小车二维码
            Short middleCodeNum = null;
            Integer middleToDistDistance = null;//计算中间点到目标点行走距离
            if (nodes.size() > 10) {//中段码传倒数第三个
                //中间路径
                middlePath = nodes.get(nodes.size() - 3);
                //通过xy坐标小车二维码
                middleCodeNum = NavigatePositionConvert.xyToPosition(middlePath.getX(), middlePath.getY(), middlePath.getZ());
                middleToDistDistance = NavigateUtils.getMiddleToDistDistance(nodes);//计算中间点到目标点行走距离
            } else if (nodes.size() > 5) {//中段码传倒数第二个
                //中间路径
                middlePath = nodes.get(nodes.size() - 2);
                //通过xy坐标小车二维码
                middleCodeNum = NavigatePositionConvert.xyToPosition(middlePath.getX(), middlePath.getY(), middlePath.getZ());
                middleToDistDistance = NavigateUtils.getMiddleToDistDistance(nodes);//计算中间点到目标点行走距离
            }

            //目标路径
            NavigateNode endPath = nodes.get(nodes.size() - 1);
            Integer allDistance = NavigateUtils.getCurrentPathAllDistance(nodes);//计算当前路径行走总距离
            Integer middleToDistDistance = NavigateUtils.getMiddleToDistDistance(nodes);//计算中间点到目标点行走距离
            //通过xy坐标小车二维码
            Short startCodeNum = NavigatePositionConvert.xyToPosition(startPath.getX(), startPath.getY(), startPath.getZ());
            //通过xy坐标小车二维码
            Short middleCodeNum = NavigatePositionConvert.xyToPosition(middlePath.getX(), middlePath.getY(), middlePath.getZ());
            //通过xy坐标小车二维码
            Short distCodeNum = NavigatePositionConvert.xyToPosition(endPath.getX(), endPath.getY(), endPath.getZ());
            //获取移动命令
@@ -881,10 +982,14 @@
        List<NavigateNode> allNode = new ArrayList<>();

        //计算小车起点到中点所需命令
        List<NavigateNode> calc = NavigateUtils.calc(startLocNo, middleLocNo, NavigationMapType.NORMAL.id);//小车无货，走正常库位通道
        List<NavigateNode> calc = NavigateUtils.calc(startLocNo, middleLocNo, NavigationMapType.NORMAL.id, null);//小车无货，走正常库位通道
        List<ShuttleCommand> commands = new ArrayList<>();

        if (calc != null) {
            if (!Utils.checkShuttlePath(calc, shuttleThread.getSlave().getId())) {//检测穿梭车行走路径，是否存在其他小车，如有其他小车则进行调离
                return null;
            }

            allNode.addAll(calc);
            //获取分段路径
            ArrayList<ArrayList<NavigateNode>> data = NavigateUtils.getSectionPath(calc);
@@ -892,17 +997,32 @@
            for (ArrayList<NavigateNode> nodes : data) {
                //开始路径
                NavigateNode startPath = nodes.get(0);

                //中间路径
                NavigateNode middlePath = nodes.get(nodes.size() - 2);
                NavigateNode middlePath = null;
                //通过xy坐标小车二维码
                Short middleCodeNum = null;
                Integer middleToDistDistance = null;//计算中间点到目标点行走距离
                if (nodes.size() > 10) {//中段码传倒数第三个
                    //中间路径
                    middlePath = nodes.get(nodes.size() - 3);
                    //通过xy坐标小车二维码
                    middleCodeNum = NavigatePositionConvert.xyToPosition(middlePath.getX(), middlePath.getY(), middlePath.getZ());
                    middleToDistDistance = NavigateUtils.getMiddleToDistDistance(nodes);//计算中间点到目标点行走距离
                } else if (nodes.size() > 5) {//中段码传倒数第二个
                    //中间路径
                    middlePath = nodes.get(nodes.size() - 2);
                    //通过xy坐标小车二维码
                    middleCodeNum = NavigatePositionConvert.xyToPosition(middlePath.getX(), middlePath.getY(), middlePath.getZ());
                    middleToDistDistance = NavigateUtils.getMiddleToDistDistance(nodes);//计算中间点到目标点行走距离
                }

                //目标路径
                NavigateNode endPath = nodes.get(nodes.size() - 1);
                Integer allDistance = NavigateUtils.getCurrentPathAllDistance(nodes);//计算当前路径行走总距离
                Integer middleToDistDistance = NavigateUtils.getMiddleToDistDistance(nodes);//计算中间点到目标点行走距离

                //通过xy坐标小车二维码
                Short startCodeNum = NavigatePositionConvert.xyToPosition(startPath.getX(), startPath.getY(), startPath.getZ());
                //通过xy坐标小车二维码
                Short middleCodeNum = NavigatePositionConvert.xyToPosition(middlePath.getX(), middlePath.getY(), middlePath.getZ());
                //通过xy坐标小车二维码
                Short distCodeNum = NavigatePositionConvert.xyToPosition(endPath.getX(), endPath.getY(), endPath.getZ());
                //获取移动命令
@@ -915,11 +1035,13 @@
        commands.add(shuttleThread.getPalletCommand((short) 1));

        //计算小车中点到终点所需命令
        List<NavigateNode> calc2 = NavigateUtils.calc(middleLocNo, locNo, NavigationMapType.DFX.id);//小车有货，走禁用过DFX库位的地图通道
        List<NavigateNode> calc2 = NavigateUtils.calc(middleLocNo, locNo, NavigationMapType.DFX.id, null);//小车有货，走禁用过DFX库位的地图通道
        if (calc2 == null) {
            return null;
        }

        if (!Utils.checkShuttlePath(calc2, shuttleThread.getSlave().getId())) {//检测穿梭车行走路径，是否存在其他小车，如有其他小车则进行调离
            return null;
        }
        allNode.addAll(calc2);

        //获取分段路径
@@ -984,9 +1106,19 @@
                    LiftProtocol liftProtocol = liftThread.getLiftProtocol();

                    if (wrkMast.getWrkSts() == 21) {
                        //寻找最近且空闲的四向穿梭车
                        searchIdleShuttle = this.searchIdleShuttle(wrkMast);
                        shuttleThread = (ShuttleThread) searchIdleShuttle.get("result");
                        if (wrkMast.getShuttleNo() == null) {
                            //寻找最近且空闲的四向穿梭车
                            searchIdleShuttle = this.searchIdleShuttle(wrkMast);
                            shuttleThread = (ShuttleThread) searchIdleShuttle.get("result");
                            if (shuttleThread == null) {
                                continue;
                            }
                            wrkMast.setShuttleNo(shuttleThread.getSlave().getId());//给工作档分配四向穿梭车号
                            wrkMastMapper.updateById(wrkMast);
                        }else {
                            //直接使用任务保存中的小车
                            shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, wrkMast.getShuttleNo());
                        }
                    }else if(wrkMast.getWrkSts() == 25) {//状态25，需要向小车下发命令从提升机移动出去，需要判断提升机状是否空闲、提升机是否到达目标楼层、目标楼层站点是否存在、目标楼层站点是否给出提升机到位信号

                        //判断提升机是否空闲
@@ -1006,8 +1138,11 @@
                        //判断提升机楼层是否到位，判断站点是否给出提升机到位信号
                        String locNo = wrkMast.getSourceLocNo();
                        int lev = Utils.getLev(locNo);//目标二维码所在楼层
                        int liftLev = liftProtocol.getLev().intValue();//提升机所在楼层
                        if (liftLev != lev) {
                        Short liftLev = liftProtocol.getLev();//提升机所在楼层
                        if (liftLev == null) {//提升机可能在输送线楼层
                            continue;
                        }
                        if (liftLev.intValue() != lev) {
                            continue;//提升机不在目标楼层跳过
                        }

@@ -1038,17 +1173,16 @@
                        continue;
                    }

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

                    if (outStaLocNo == null) {
                        continue;
                    }

                    if (wrkMast.getWrkSts() == 21) {

                        wrkMast.setShuttleNo(shuttleProtocol.getShuttleNo().intValue());//给工作档分配四向穿梭车号
                        if (!shuttleProtocol.isIdle()) {
                            continue;
                        }

                        //源库位(小车当前位置)
                        String currentLocNo = shuttleProtocol.getCurrentLocNo();

@@ -1067,27 +1201,14 @@
                        assignCommand.setSourceLocNo(currentLocNo);

                        //判断小车和库位是否在同一层
                        if (Boolean.parseBoolean(searchIdleShuttle.get("sameLay").toString())) {
                        if (currentLev == Utils.getLev(wrkMast.getSourceLocNo())) {
                            //同一层(将小车移动到货物位置)

                            List<ShuttleCommand> commands = this.shuttleAssignCommand(currentLocNo, wrkMast.getSourceLocNo(), liftSiteLocNo, assignCommand, shuttleThread);
                            if (commands == null) {
                                //未找到路径，等待下一次
                                continue;
                            }

                            //获取当前小车所在楼层的站点信息
                            BasDevp basDevp = basDevpService.queryByLocNo(liftSiteLocNo);
                            Short endStartCode = Short.parseShort(basDevp.getQrCodeValue());//站点二维码

                            String disLocNo = "200020" + Utils.getLev(liftSiteLocNo);//避让位置
                            LocMast locMast1 = locMastService.queryByLoc(disLocNo);
                            if (locMast1 == null) {
                                continue;//找不到库位
                            }
                            short disCode = Short.parseShort(locMast1.getQrCodeValue());
                            //任务执行完后，小车进入移开提升机口站点位置，以免坠落
                            ShuttleCommand moveCommand = shuttleThread.getMoveCommand(endStartCode, disCode, 2800, ShuttleRunDirection.BOTTOM.id, endStartCode, 2800, 1000);
                            commands.add(moveCommand);

                            //分配目标库位
                            shuttleProtocol.setLocNo(wrkMast.getSourceLocNo());
@@ -1126,7 +1247,7 @@
                            Short endStartCode = Short.parseShort(basDevp.getQrCodeValue());//站点二维码

                            //增加移动进提升机命令
                            ShuttleCommand moveCommand = shuttleThread.getMoveCommand(endStartCode, liftProtocol.getBarcode(), 1400, ShuttleRunDirection.TOP.id, endStartCode, 1400, 500);
                            ShuttleCommand moveCommand = shuttleThread.getMoveCommand(endStartCode, liftProtocol.getBarcode(), 1400, ShuttleRunDirection.TOP.id, null, null, 500);
                            commands.add(moveCommand);

                            //目标库位
@@ -1140,6 +1261,9 @@
                            }
                        }
                    } else if (wrkMast.getWrkSts() == 25) {
                        if (!shuttleProtocol.isIdle(wrkMast.getWrkNo().shortValue())) {
                            continue;
                        }

                        wrkMast.setShuttleNo(shuttleProtocol.getShuttleNo().intValue());//给工作档分配四向穿梭车号

@@ -1155,30 +1279,16 @@
                        assignCommand.setTaskMode(ShuttleTaskModeType.PAK_OUT.id.shortValue());
                        assignCommand.setSourceLocNo(liftSiteLocNo);

                        //获取当前小车所在楼层的站点信息
                        BasDevp basDevp = basDevpService.queryByLocNo(liftSiteLocNo);
                        Short endStartCode = Short.parseShort(basDevp.getQrCodeValue());//站点二维码

                        String disLocNo = "200020" + Utils.getLev(liftSiteLocNo);//避让位置
                        LocMast locMast1 = locMastService.queryByLoc(disLocNo);
                        if (locMast1 == null) {
                            continue;//找不到库位
                        }
                        short disCode = Short.parseShort(locMast1.getQrCodeValue());
                        //任务执行完后，小车进入移开提升机口站点位置，以免坠落
                        ShuttleCommand moveCommand2 = shuttleThread.getMoveCommand(endStartCode, disCode, 2800, ShuttleRunDirection.BOTTOM.id, endStartCode, 2800, 1000);

                        List<ShuttleCommand> commands = this.shuttleAssignCommand(liftSiteLocNo, wrkMast.getSourceLocNo(), liftSiteLocNo, assignCommand, shuttleThread);
                        if (commands == null) {
                            continue;//未找到路径
                        }
                        commands.add(moveCommand2);//任务执行完后，小车进入移开提升机口站点位置，以免坠落

                        //此时车在提升机内部，需要多下达一步指令让车移动到提升机口
                        short startCode = liftProtocol.getBarcode();//提升机内部二维码
                        Short distCode = commands.get(0).getStartCodeNum();//目标二维码
                        //获取移动命令
                        ShuttleCommand moveCommand = shuttleThread.getMoveCommand(startCode, distCode, 1400, commands.get(0).getRunDirection(), startCode, 1400, 500);
                        ShuttleCommand moveCommand = shuttleThread.getMoveCommand(startCode, distCode, 1400, commands.get(0).getRunDirection(), null, null, 500);
                        commands.add(0, moveCommand);//将该指令添加到队头

                        //分配目标库位
@@ -1226,6 +1336,18 @@
            distLocNo = locNo;
        }

        //判断当前任务所在楼层是否有其他任务已经分配了小车，如有则直接用该小车(一层楼仅分配一台车)
        List<WrkMast> wrkMasts = wrkMastService.selectShuttleWrkByLev(lev);//判断当前穿梭车楼层是否已有分配车辆的任务，如果有则分配这辆车
        if (wrkMasts.size() > 0) {
            //存在其他任务，分配这辆车
            WrkMast wrkMast1 = wrkMasts.get(0);
            ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, wrkMast1.getShuttleNo());

            map.put("sameLay", true);//同层
            map.put("result", shuttleThread);
            return map;
        }

        for (ShuttleSlave shuttle : slaveProperties.getShuttle()) {
            //获取四向穿梭车线程
            ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, shuttle.getId());
@@ -1260,27 +1382,18 @@

        }

        Integer recentAllDistance = 9999999;
        if (sameLev.size() > 0) {
            //同一楼层有空闲穿梭车，则只在工作档楼层寻找
            //寻找离任务最近的穿梭车
            for (ShuttleThread shuttleThread : sameLev) {
                if (recentShuttle == null) {//最近穿梭车为空，则默认赋予为最近穿梭车
                    recentShuttle = shuttleThread;
                }

                //当前穿梭车库位号
                String currentLocNo = shuttleThread.getShuttleProtocol().getCurrentLocNo();
                //目前最近穿梭车库位号
                String recentLocNo = recentShuttle.getShuttleProtocol().getCurrentLocNo();

                //当前最近四向穿梭车到目标地点距离
                List<NavigateNode> recentShuttlePath = NavigateUtils.calc(recentLocNo, distLocNo, NavigationMapType.NORMAL.id);//搜索空闲穿梭车，使用正常通道地图
                //当前穿梭车线程到目标地点距离
                List<NavigateNode> currentShuttlePath = NavigateUtils.calc(currentLocNo, distLocNo, NavigationMapType.NORMAL.id);//搜索空闲穿梭车，使用正常通道地图
                if (recentShuttlePath == null || currentShuttlePath == null) {
                List<NavigateNode> currentShuttlePath = NavigateUtils.calc(currentLocNo, distLocNo, NavigationMapType.NORMAL.id, Utils.getShuttlePoints(shuttleThread.getSlave().getId(), Utils.getLev(currentLocNo)));//搜索空闲穿梭车，使用正常通道地图
                if (currentShuttlePath == null) {
                    continue;
                }
                Integer recentAllDistance = NavigateUtils.getOriginPathAllDistance(recentShuttlePath);//计算当前路径行走总距离
                Integer currentAllDistance = NavigateUtils.getOriginPathAllDistance(currentShuttlePath);//计算当前路径行走总距离
                if (currentAllDistance < recentAllDistance) {
                    //如果当前楼层的车路径更小，则更新最近穿梭车
@@ -1294,26 +1407,22 @@
            //同一楼层，没有空闲穿梭车，只能从其他楼层调度
            //寻找离任务最近的穿梭车
            for (ShuttleThread shuttleThread : diffLev) {
                if (recentShuttle == null) {//最近穿梭车为空，则默认赋予为最近穿梭车
                    recentShuttle = shuttleThread;
                }

                //当前穿梭车库位号
                String currentLocNo = shuttleThread.getShuttleProtocol().getCurrentLocNo();
                int currentLev = Utils.getLev(currentLocNo);
                //目前最近穿梭车库位号
                String recentLocNo = recentShuttle.getShuttleProtocol().getCurrentLocNo();
                int recentLev = Utils.getLev(recentLocNo);

                //当前最近四向穿梭车到当前车子所在楼层的提升机口距离
                List<NavigateNode> recentShuttlePath = NavigateUtils.calc(recentLocNo, Utils.levToOutInStaLocNo(recentLev), NavigationMapType.NORMAL.id);//搜索空闲穿梭车，使用正常通道地图
                //当前穿梭车线程到当前车子所在楼层的提升机口距离
                List<NavigateNode> currentShuttlePath = NavigateUtils.calc(currentLocNo, Utils.levToOutInStaLocNo(currentLev), NavigationMapType.NORMAL.id);//搜索空闲穿梭车，使用正常通道地图
                if (recentShuttlePath == null || currentShuttlePath == null) {
                List<WrkMast> wrkMasts1 = wrkMastService.selectNoShuttleWrkByLev(currentLev);//判断当前穿梭车楼层是否有待分配车辆的任务，如果有则不分配这辆车
                if (wrkMasts1.size() > 0) {
                    //存在其他任务，跳过这辆车
                    continue;
                }

                Integer recentAllDistance = NavigateUtils.getOriginPathAllDistance(recentShuttlePath);//计算当前路径行走总距离
                //当前穿梭车线程到当前车子所在楼层的提升机口距离
                List<NavigateNode> currentShuttlePath = NavigateUtils.calc(currentLocNo, Utils.levToOutInStaLocNo(currentLev), NavigationMapType.NORMAL.id, Utils.getShuttlePoints(shuttleThread.getSlave().getId(), currentLev));//搜索空闲穿梭车，使用正常通道地图
                if (currentShuttlePath == null) {
                    continue;
                }

                Integer currentAllDistance = NavigateUtils.getOriginPathAllDistance(currentShuttlePath);//计算当前路径行走总距离
                if (currentAllDistance < recentAllDistance) {
                    //如果当前楼层的车路径更小，则更新最近穿梭车
@@ -1347,12 +1456,17 @@
                //标记复位
                shuttleProtocol.setPakMk(true);

                ShuttleAssignCommand assignCommand = shuttleProtocol.getAssignCommand();

                //将任务档标记为完成
                WrkMast wrkMast = wrkMastMapper.selectByWorkNo(shuttleProtocol.getTaskNo().intValue());
                ShuttleAssignCommand moveAssignCommand = null;//避让命令
                if (wrkMast != null) {
                    switch (wrkMast.getWrkSts().intValue()) {
                        case 9://9.小车入库搬运中 ==> 14.入库完成
                            wrkMast.setWrkSts(14L);
                            //任务号清零
                            shuttleProtocol.setTaskNo((short) 0);
                            break;
                        case 5://5.迁移小车至提升机口 ==> 6.迁移小车至提升机口完成
                            wrkMast.setWrkSts(6L);
@@ -1361,12 +1475,54 @@
                            wrkMast.setWrkSts(23L);
                            break;
                        case 26://26.小车出库搬运中 ==> 27.小车出库搬运完成
                            //任务执行完后，小车进入移开提升机口站点位置，以免坠落
                            //搜索一条没有小车的空巷道，并调度小车
                            int distLev = Utils.getLev(wrkMast.getSourceLocNo());//避让楼层
                            String startLocNo = "180020" + distLev;
                            moveAssignCommand = Utils.searchEmptyGroupToMoveShuttle(distLev, shuttleThread.getSlave().getId(), shuttleThread, startLocNo);
                            if (moveAssignCommand == null) {//调度小车命令为空
                                continue;
                            }

                            wrkMast.setWrkSts(27L);
                            //任务号清零
                            shuttleProtocol.setTaskNo((short) 0);
                            break;
                        default:
                    }

                    if (wrkMastMapper.updateById(wrkMast) > 0) {
                        //设置四向穿梭车为空闲状态
                        shuttleProtocol.setProtocolStatus(ShuttleProtocolStatusType.IDLE);
                        //源库位清零
                        shuttleProtocol.setSourceLocNo(null);
                        //目标库位清零
                        shuttleProtocol.setLocNo(null);
                        //任务指令清零
                        shuttleProtocol.setAssignCommand(null);
                        News.info("四向穿梭车已确认且任务完成状态,复位。四向穿梭车号={}", shuttleProtocol.getShuttleNo());

                        if (wrkMast.getWrkSts() == 27) {
                            if (moveAssignCommand != null) {
                                try {
                                    Thread.sleep(4000);
                                    //下发任务
                                    shuttleProtocol.setPakMk(true);
                                    MessageQueue.offer(SlaveType.Shuttle, shuttleThread.getSlave().getId(), new Task(3, moveAssignCommand));
                                } catch (InterruptedException e) {
                                    throw new RuntimeException(e);
                                }
                            }
                        }

                    } else {
                        News.error("四向穿梭车已确认且任务完成状态,复位失败，但未找到工作档。四向穿梭车号={}，工作号={}", shuttleProtocol.getShuttleNo(), shuttleProtocol.getTaskNo());
                    }
                }

                if (assignCommand != null) {
                    if (assignCommand.getTaskMode().intValue() == ShuttleTaskModeType.AVOID.id) {
                        //避让任务
                        //设置四向穿梭车为空闲状态
                        shuttleProtocol.setProtocolStatus(ShuttleProtocolStatusType.IDLE);
                        //任务号清零
@@ -1377,9 +1533,7 @@
                        shuttleProtocol.setLocNo(null);
                        //任务指令清零
                        shuttleProtocol.setAssignCommand(null);
                        News.info("四向穿梭车已确认且任务完成状态,复位。四向穿梭车号={}", shuttleProtocol.getShuttleNo());
                    } else {
                        News.error("四向穿梭车已确认且任务完成状态,复位失败，但未找到工作档。四向穿梭车号={}，工作号={}", shuttleProtocol.getShuttleNo(), shuttleProtocol.getTaskNo());
                        News.info("四向穿梭车避让任务已确认且任务完成状态,复位。四向穿梭车号={}", shuttleProtocol.getShuttleNo());
                    }
                }

@@ -1454,240 +1608,253 @@
            }

            //搜索是否有待处理的任务
            WrkMast wrkMast = wrkMastMapper.selectLiftStep262327();
            if (wrkMast == null) {
            List<WrkMast> wrkMasts = wrkMastMapper.selectLiftStep262327();
            if (wrkMasts.size() == 0) {
                continue;
            }

            //命令list
            ArrayList<LiftCommand> commands = new ArrayList<>();

            DevpThread devpThread = null;
            Integer devpId = null;
            for (DevpSlave devp : slaveProperties.getDevp()){
                // 获取入库站信息
                devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, devp.getId());
                devpId = devp.getId();
            }

            if (wrkMast.getWrkSts() == 2) {//2.设备上走
                if (liftProtocol.getTaskNo().intValue() != 0) {
                    //存在未完成任务号
                    continue;
                }
                if (liftProtocol.getPlatShuttleCheck()) {
                    //提升机此时有四向车，可能有未完成的任务，禁止分配新任务
            for (WrkMast wrkMast : wrkMasts) {
                //搜索是否有其他任务占用了提升机，如果占用提升机的任务和当前任务相同，则运行执行
                WrkMast wrkMast1 = wrkMastMapper.selectLiftWrkMast(liftProtocol.getLiftNo().intValue());
                if (wrkMast1 != null && wrkMast1.getWrkNo().intValue() != wrkMast.getWrkNo().intValue()) {
                    continue;
                }

                //获取目标站
                StaProtocol staProtocol = devpThread.getStation().get(wrkMast.getStaNo());
                if (staProtocol.isLoading() || !staProtocol.isInEnable()) {//目标站有物，不可入，禁止分配任务
                    continue;
                //命令list
                ArrayList<LiftCommand> commands = new ArrayList<>();

                DevpThread devpThread = null;
                Integer devpId = null;
                for (DevpSlave devp : slaveProperties.getDevp()){
                    // 获取入库站信息
                    devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, devp.getId());
                    devpId = devp.getId();
                }

                //工作档目标库位号
                String wrkMastLocNo = wrkMast.getLocNo();
                //工作档目标库位楼层
                int wrkMastLocNoLey = Utils.getLev(wrkMastLocNo);
                if (wrkMast.getWrkSts() == 2) {//2.设备上走
                    if (liftProtocol.getTaskNo().intValue() != 0) {
                        //存在未完成任务号
                        continue;
                    }
                    if (liftProtocol.getPlatShuttleCheck()) {
                        //提升机此时有四向车，可能有未完成的任务，禁止分配新任务
                        continue;
                    }

                Integer levTmp = wrkMastLocNoLey;
                if (wrkMastLocNoLey >= 2) {
                    levTmp += 1;
                }
                Integer distStaNo = Utils.levToOutInStaNo(levTmp);
                    //获取目标站
                    StaProtocol staProtocol = devpThread.getStation().get(wrkMast.getStaNo());
                    if (staProtocol.isLoading() || !staProtocol.isInEnable()) {//目标站有物，不可入，禁止分配任务
                        continue;
                    }

                if (liftProtocol.getPositionArrivalFeedback().intValue() != LiftLevType.TWO.realLev.intValue()) {
                    //提升机不在输送线楼层，获取到输送线层的提升机命令
                    LiftCommand command1 = liftThread.getLiftUpDownCommand(liftProtocol.getLiftNo(), liftProtocol.getTaskNo(), LiftLevType.TWO.lev);
                    commands.add(command1);//将命令添加进list
                }
                    //工作档目标库位号
                    String wrkMastLocNo = wrkMast.getLocNo();
                    //工作档目标库位楼层
                    int wrkMastLocNoLey = Utils.getLev(wrkMastLocNo);

                //输送线将货物运进来(无货正转)
                LiftCommand command2 = liftThread.getLiftTurnCommand(liftProtocol.getLiftNo(), liftProtocol.getTaskNo(), 3);
                command2.setOperaStaNo((short) 102);//操作102站
                command2.setRotationDire(1);//给输送线下发链条转动信号，正转
                command2.setDevpId(devpId);
                command2.setStaNo(distStaNo.shortValue());//设置目标站
                commands.add(command2);//将命令添加进list
                    Integer levTmp = wrkMastLocNoLey;
                    if (wrkMastLocNoLey >= 2) {
                        levTmp += 1;
                    }
                    Integer distStaNo = Utils.levToOutInStaNo(levTmp);

                //提升机前往目标楼层(工作档目标楼层)
                LiftCommand command3 = liftThread.getLiftUpDownCommand(liftProtocol.getLiftNo(), liftProtocol.getTaskNo(), levTmp);
                commands.add(command3);//将命令添加进list
                    if (liftProtocol.getPositionArrivalFeedback().intValue() != LiftLevType.TWO.realLev.intValue()) {
                        //提升机不在输送线楼层，获取到输送线层的提升机命令
                        LiftCommand command1 = liftThread.getLiftUpDownCommand(liftProtocol.getLiftNo(), liftProtocol.getTaskNo(), LiftLevType.TWO.lev);
                        commands.add(command1);//将命令添加进list
                    }

                //提升机到达指定楼层，输送线将货物移出去(正转)
                //输送线将货物移出去
                LiftCommand command4 = liftThread.getLiftTurnCommand(liftProtocol.getLiftNo(), liftProtocol.getTaskNo(), 1);
                command4.setOperaStaNo(distStaNo.shortValue());//操作目标楼层站点
                command4.setRotationDire(1);//给输送线下发链条转动信号，正转
                command4.setDevpId(devpId);
                command4.setStaNo(distStaNo.shortValue());//设置目标站
                commands.add(command4);//将命令添加进list
                    //输送线将货物运进来(无货正转)
                    LiftCommand command2 = liftThread.getLiftTurnCommand(liftProtocol.getLiftNo(), liftProtocol.getTaskNo(), 3);
                    command2.setOperaStaNo((short) 102);//操作102站
                    command2.setRotationDire(1);//给输送线下发链条转动信号，正转
                    command2.setDevpId(devpId);
                    command2.setStaNo(distStaNo.shortValue());//设置目标站
                    commands.add(command2);//将命令添加进list

                //给提升机分配任务
                liftProtocol.setTaskNo(wrkMast.getWrkNo().shortValue());//设置任务号
                liftProtocol.setProtocolStatus(LiftProtocolStatusType.WORKING);//设置提升机状态为工作中
                    //提升机前往目标楼层(工作档目标楼层)
                    LiftCommand command3 = liftThread.getLiftUpDownCommand(liftProtocol.getLiftNo(), liftProtocol.getTaskNo(), levTmp);
                    commands.add(command3);//将命令添加进list

                wrkMast.setWrkSts(3L);//3.提升机搬运中
            } else if (wrkMast.getWrkSts() == 6) {//6.迁移小车至提升机口完成 => 7.提升机迁移小车中
                if (liftProtocol.getTaskNo().intValue() != 0 && liftProtocol.getTaskNo().intValue() != wrkMast.getWrkNo()) {
                    //提升机存在未完成任务，且提升机任务号和当前工作档任务号不一致
                    continue;
                }
                liftProtocol.setShuttleNo(wrkMast.getShuttleNo().shortValue());//设置四向穿梭车号
                    //提升机到达指定楼层，输送线将货物移出去(正转)
                    //输送线将货物移出去
                    LiftCommand command4 = liftThread.getLiftTurnCommand(liftProtocol.getLiftNo(), liftProtocol.getTaskNo(), 1);
                    command4.setOperaStaNo(distStaNo.shortValue());//操作目标楼层站点
                    command4.setRotationDire(1);//给输送线下发链条转动信号，正转
                    command4.setDevpId(devpId);
                    command4.setStaNo(distStaNo.shortValue());//设置目标站
                    commands.add(command4);//将命令添加进list

                //判断小车是否在提升机内，且处于空闲状态
                ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, wrkMast.getShuttleNo());
                if (shuttleThread == null) {
                    continue;
                }
                ShuttleProtocol shuttleProtocol = shuttleThread.getShuttleProtocol();
                if (shuttleProtocol == null) {
                    continue;
                }
                if (!shuttleProtocol.isIdle()) {
                    continue;//小车状态忙
                }
                if (shuttleProtocol.getCurrentCode().intValue() != liftProtocol.getBarcode().intValue()) {
                    continue;//小车当前二维码和提升机内部二维码不一致，不允许执行
                }
                if (!liftProtocol.getPlatShuttleCheck()) {
                    //提升机未检测到小车，禁止执行
                    continue;
                }
                    //给提升机分配任务
                    liftProtocol.setTaskNo(wrkMast.getWrkNo().shortValue());//设置任务号
                    liftProtocol.setProtocolStatus(LiftProtocolStatusType.WORKING);//设置提升机状态为工作中

                //工作档目标库位号
                String wrkMastLocNo = wrkMast.getLocNo();
                //工作档目标库位楼层
                int wrkMastLocNoLey = Utils.getLev(wrkMastLocNo);
                if (wrkMastLocNoLey >= 2) {
                    wrkMastLocNoLey++;
                }
                    wrkMast.setLiftNo(liftProtocol.getLiftNo().intValue());//设置提升机号用于锁定提升机防止被其他任务占用
                    wrkMast.setWrkSts(3L);//3.提升机搬运中
                } else if (wrkMast.getWrkSts() == 6) {//6.迁移小车至提升机口完成 => 7.提升机迁移小车中
                    if (liftProtocol.getTaskNo().intValue() != 0 && liftProtocol.getTaskNo().intValue() != wrkMast.getWrkNo()) {
                        //提升机存在未完成任务，且提升机任务号和当前工作档任务号不一致
                        continue;
                    }
                    liftProtocol.setShuttleNo(wrkMast.getShuttleNo().shortValue());//设置四向穿梭车号

                //提升机前往目标楼层(工作档目标楼层)
                LiftCommand command1 = liftThread.getLiftUpDownCommand(liftProtocol.getLiftNo(), liftProtocol.getTaskNo(), wrkMastLocNoLey);
                commands.add(command1);//将命令添加进list
                    //判断小车是否在提升机内，且处于空闲状态
                    ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, wrkMast.getShuttleNo());
                    if (shuttleThread == null) {
                        continue;
                    }
                    ShuttleProtocol shuttleProtocol = shuttleThread.getShuttleProtocol();
                    if (shuttleProtocol == null) {
                        continue;
                    }
                    if (!shuttleProtocol.isIdle(wrkMast.getWrkNo().shortValue())) {
                        continue;//小车状态忙
                    }
                    if (shuttleProtocol.getCurrentCode().intValue() != liftProtocol.getBarcode().intValue()) {
                        continue;//小车当前二维码和提升机内部二维码不一致，不允许执行
                    }
                    if (!liftProtocol.getPlatShuttleCheck()) {
                        //提升机未检测到小车，禁止执行
                        continue;
                    }

                //给提升机分配任务
                liftProtocol.setTaskNo(wrkMast.getWrkNo().shortValue());//设置任务号
                liftProtocol.setProtocolStatus(LiftProtocolStatusType.WORKING);//设置提升机状态为工作中
                    //工作档目标库位号
                    String wrkMastLocNo = wrkMast.getLocNo();
                    //工作档目标库位楼层
                    int wrkMastLocNoLey = Utils.getLev(wrkMastLocNo);
                    if (wrkMastLocNoLey >= 2) {
                        wrkMastLocNoLey++;
                    }

                wrkMast.setWrkSts(7L);//6.迁移小车至提升机口完成 => 7.提升机迁移小车中
            } else if(wrkMast.getWrkSts() == 23) {//23.迁移小车至提升机口完成 => 24.提升机迁移小车中
                if (liftProtocol.getTaskNo().intValue() != 0 && liftProtocol.getTaskNo().intValue() != wrkMast.getWrkNo()) {
                    //提升机存在未完成任务，且提升机任务号和当前工作档任务号不一致
                    continue;
                }
                liftProtocol.setShuttleNo(wrkMast.getShuttleNo().shortValue());//设置四向穿梭车号

                //判断小车是否在提升机内，且处于空闲状态
                ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, wrkMast.getShuttleNo());
                if (shuttleThread == null) {
                    continue;
                }
                ShuttleProtocol shuttleProtocol = shuttleThread.getShuttleProtocol();
                if (shuttleProtocol == null) {
                    continue;
                }

                if (!shuttleProtocol.isIdle()) {
                    continue;//小车状态忙
                }
                if (shuttleProtocol.getCurrentCode().intValue() != liftProtocol.getBarcode().intValue()) {
                    continue;//小车当前二维码和提升机内部二维码不一致，不允许执行
                }
                if (!liftProtocol.getPlatShuttleCheck()) {
                    //提升机未检测到小车，禁止执行
                    continue;
                }

                //工作档目标库位号
                String wrkMastLocNo = wrkMast.getSourceLocNo();
                //工作档目标库位楼层
                int wrkMastLocNoLey = Utils.getLev(wrkMastLocNo);
                if (wrkMastLocNoLey >= 2) {
                    wrkMastLocNoLey++;
                }

                //提升机前往目标楼层(工作档目标楼层)
                LiftCommand command1 = liftThread.getLiftUpDownCommand(liftProtocol.getLiftNo(), liftProtocol.getTaskNo(), wrkMastLocNoLey);
                commands.add(command1);//将命令添加进list

                //给提升机分配任务
                liftProtocol.setTaskNo(wrkMast.getWrkNo().shortValue());//设置任务号
                liftProtocol.setProtocolStatus(LiftProtocolStatusType.WORKING);//设置提升机状态为工作中

                wrkMast.setWrkSts(24L);//23.迁移小车至提升机口完成 => 24.提升机迁移小车中
            } else if (wrkMast.getWrkSts() == 27) {//27.小车出库搬运完成
                if (liftProtocol.getTaskNo().intValue() != 0 && liftProtocol.getTaskNo().intValue() != wrkMast.getWrkNo()) {
                    //提升机存在未完成任务，且提升机任务号和当前工作档任务号不一致
                    continue;
                }
                if (liftProtocol.getPlatShuttleCheck()) {
                    //提升机此时有四向车，可能有未完成的任务，禁止分配新任务
                    continue;
                }

                //工作档源库位号
                String wrkMastLocNo = wrkMast.getSourceLocNo();
                //工作档源库位楼层
                int wrkMastLocNoLey = Utils.getLev(wrkMastLocNo);

                //提升机当前楼层
                int liftLev = liftProtocol.getLev().intValue();

                //判断提升机是否到位
                StaProtocol staProtocol = devpThread.getStation().get(Utils.levToOutInStaNo(wrkMastLocNoLey >= 2 ? wrkMastLocNoLey + 1 : wrkMastLocNoLey));//起始站点
                if (liftLev != wrkMastLocNoLey && !staProtocol.isLiftArrival()) {
                    //提升机不在工作档源库位楼层，调度提升机
                    //提升机前往目标楼层(工作档目标楼层)
                    LiftCommand command1 = liftThread.getLiftUpDownCommand(liftProtocol.getLiftNo(), liftProtocol.getTaskNo(), wrkMastLocNoLey);
                    commands.add(command1);//将命令添加进list

                    //给提升机分配任务
                    liftProtocol.setTaskNo(wrkMast.getWrkNo().shortValue());//设置任务号
                    liftProtocol.setProtocolStatus(LiftProtocolStatusType.WORKING);//设置提升机状态为工作中

                    wrkMast.setLiftNo(liftProtocol.getLiftNo().intValue());//设置提升机号用于锁定提升机防止被其他任务占用
                    wrkMast.setWrkSts(7L);//6.迁移小车至提升机口完成 => 7.提升机迁移小车中
                } else if(wrkMast.getWrkSts() == 23) {//23.迁移小车至提升机口完成 => 24.提升机迁移小车中
                    if (liftProtocol.getTaskNo().intValue() != 0 && liftProtocol.getTaskNo().intValue() != wrkMast.getWrkNo()) {
                        //提升机存在未完成任务，且提升机任务号和当前工作档任务号不一致
                        continue;
                    }
                    liftProtocol.setShuttleNo(wrkMast.getShuttleNo().shortValue());//设置四向穿梭车号

                    //判断小车是否在提升机内，且处于空闲状态
                    ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, wrkMast.getShuttleNo());
                    if (shuttleThread == null) {
                        continue;
                    }
                    ShuttleProtocol shuttleProtocol = shuttleThread.getShuttleProtocol();
                    if (shuttleProtocol == null) {
                        continue;
                    }

                    if (!shuttleProtocol.isIdle(wrkMast.getWrkNo().shortValue())) {
                        continue;//小车状态忙
                    }
                    if (shuttleProtocol.getCurrentCode().intValue() != liftProtocol.getBarcode().intValue()) {
                        continue;//小车当前二维码和提升机内部二维码不一致，不允许执行
                    }
                    if (!liftProtocol.getPlatShuttleCheck()) {
                        //提升机未检测到小车，禁止执行
                        continue;
                    }

                    //工作档目标库位号
                    String wrkMastLocNo = wrkMast.getSourceLocNo();
                    //工作档目标库位楼层
                    int wrkMastLocNoLey = Utils.getLev(wrkMastLocNo);
                    if (wrkMastLocNoLey >= 2) {
                        wrkMastLocNoLey++;
                    }

                    //提升机前往目标楼层(工作档目标楼层)
                    LiftCommand command1 = liftThread.getLiftUpDownCommand(liftProtocol.getLiftNo(), liftProtocol.getTaskNo(), wrkMastLocNoLey);
                    commands.add(command1);//将命令添加进list

                    //给提升机分配任务
                    liftProtocol.setTaskNo(wrkMast.getWrkNo().shortValue());//设置任务号
                    liftProtocol.setProtocolStatus(LiftProtocolStatusType.WORKING);//设置提升机状态为工作中

                    wrkMast.setLiftNo(liftProtocol.getLiftNo().intValue());//设置提升机号用于锁定提升机防止被其他任务占用
                    wrkMast.setWrkSts(24L);//23.迁移小车至提升机口完成 => 24.提升机迁移小车中
                } else if (wrkMast.getWrkSts() == 27) {//27.小车出库搬运完成
                    if (liftProtocol.getTaskNo().intValue() != 0 && liftProtocol.getTaskNo().intValue() != wrkMast.getWrkNo()) {
                        //提升机存在未完成任务，且提升机任务号和当前工作档任务号不一致
                        continue;
                    }
                    if (liftProtocol.getPlatShuttleCheck()) {
                        //提升机此时有四向车，可能有未完成的任务，禁止分配新任务
                        continue;
                    }

                    //工作档源库位号
                    String wrkMastLocNo = wrkMast.getSourceLocNo();
                    //工作档源库位楼层
                    int wrkMastLocNoLey = Utils.getLev(wrkMastLocNo);

                    //提升机当前楼层
                    int liftLev = liftProtocol.getLev().intValue();

                    //判断提升机是否到位
                    StaProtocol staProtocol = devpThread.getStation().get(Utils.levToOutInStaNo(wrkMastLocNoLey >= 2 ? wrkMastLocNoLey + 1 : wrkMastLocNoLey));//起始站点
                    if (liftLev != wrkMastLocNoLey && !staProtocol.isLiftArrival()) {
                        //提升机不在工作档源库位楼层，调度提升机
                        LiftCommand command1 = liftThread.getLiftUpDownCommand(liftProtocol.getLiftNo(), liftProtocol.getTaskNo(), wrkMastLocNoLey);
                        commands.add(command1);//将命令添加进list
                    }

                    //输送线将货物运进来(无货反转)
                    LiftCommand command2 = liftThread.getLiftTurnCommand(liftProtocol.getLiftNo(), liftProtocol.getTaskNo(), 4);
                    command2.setOperaStaNo(staProtocol.getSiteId().shortValue());//输送线操作站点号
                    command2.setRotationDire(2);//给输送线下发链条转动信号，反转
                    command2.setDevpId(devpId);//输送线iD
                    command2.setStaNo((short) 104);//写入出库目标站104
                    commands.add(command2);//将命令添加进list

                    //提升机前往出库口，输送线楼层
                    LiftCommand command3 = liftThread.getLiftUpDownCommand(liftProtocol.getLiftNo(), liftProtocol.getTaskNo(), LiftLevType.TWO.lev);
                    commands.add(command3);//将命令添加进list

                    //提升机到达指定楼层，输送线将货物移出去(反转)
                    //输送线将货物移出去
                    LiftCommand command4 = liftThread.getLiftTurnCommand(liftProtocol.getLiftNo(), liftProtocol.getTaskNo(), 2);
                    command4.setOperaStaNo((short) 102);//操作102站
                    command4.setRotationDire(2);//给输送线下发链条转动信号，反转
                    command4.setDevpId(devpId);
                    commands.add(command4);//将命令添加进list

                    //提升机链条执行完毕后，给102站写入资料
                    LiftCommand command5 = liftThread.getResetCommand();
                    command5.setDevpId(devpId);//输送线iD
                    command5.setOperaStaNo((short) 102);//操作102站
                    command5.setStaNo((short) 104);//写入出库目标站104
                    command5.setRotationDire(0);//链条转动停止
                    commands.add(command5);

                    //给提升机分配任务
                    liftProtocol.setTaskNo(wrkMast.getWrkNo().shortValue());//设置任务号
                    liftProtocol.setProtocolStatus(LiftProtocolStatusType.WORKING);//设置提升机状态为工作中

                    wrkMast.setLiftNo(liftProtocol.getLiftNo().intValue());//设置提升机号用于锁定提升机防止被其他任务占用
                    wrkMast.setWrkSts(28L);//28.提升机搬运中
                }

                //输送线将货物运进来(无货反转)
                LiftCommand command2 = liftThread.getLiftTurnCommand(liftProtocol.getLiftNo(), liftProtocol.getTaskNo(), 4);
                command2.setOperaStaNo(staProtocol.getSiteId().shortValue());//输送线操作站点号
                command2.setRotationDire(2);//给输送线下发链条转动信号，反转
                command2.setDevpId(devpId);//输送线iD
                command2.setStaNo((short) 104);//写入出库目标站104
                commands.add(command2);//将命令添加进list

                //提升机前往出库口，输送线楼层
                LiftCommand command3 = liftThread.getLiftUpDownCommand(liftProtocol.getLiftNo(), liftProtocol.getTaskNo(), LiftLevType.TWO.lev);
                commands.add(command3);//将命令添加进list

                //提升机到达指定楼层，输送线将货物移出去(反转)
                //输送线将货物移出去
                LiftCommand command4 = liftThread.getLiftTurnCommand(liftProtocol.getLiftNo(), liftProtocol.getTaskNo(), 2);
                command4.setOperaStaNo((short) 102);//操作102站
                command4.setRotationDire(2);//给输送线下发链条转动信号，反转
                command4.setDevpId(devpId);
                commands.add(command4);//将命令添加进list

                //提升机链条执行完毕后，给102站写入资料
                LiftCommand command5 = liftThread.getResetCommand();
                command5.setDevpId(devpId);//输送线iD
                command5.setOperaStaNo((short) 102);//操作102站
                command5.setStaNo((short) 104);//写入出库目标站104
                command5.setRotationDire(0);//链条转动停止
                commands.add(command5);

                //给提升机分配任务
                liftProtocol.setTaskNo(wrkMast.getWrkNo().shortValue());//设置任务号
                liftProtocol.setProtocolStatus(LiftProtocolStatusType.WORKING);//设置提升机状态为工作中

                wrkMast.setWrkSts(28L);//28.提升机搬运中
                //所需命令组合完毕，更新数据库，提交到线程去工作
                LiftAssignCommand assignCommand = new LiftAssignCommand();
                assignCommand.setCommands(commands);
                assignCommand.setLiftNo(liftProtocol.getLiftNo());
                assignCommand.setTaskNo(liftProtocol.getTaskNo());
                if (wrkMastMapper.updateById(wrkMast) > 0) {
                    //下发任务
                    MessageQueue.offer(SlaveType.Lift, liftProtocol.getLiftNo().intValue(), new Task(3, assignCommand));
                }
            }

            //所需命令组合完毕，更新数据库，提交到线程去工作
            LiftAssignCommand assignCommand = new LiftAssignCommand();
            assignCommand.setCommands(commands);
            assignCommand.setLiftNo(liftProtocol.getLiftNo());
            assignCommand.setTaskNo(liftProtocol.getTaskNo());
            if (wrkMastMapper.updateById(wrkMast) > 0) {
                //下发任务
                MessageQueue.offer(SlaveType.Lift, liftProtocol.getLiftNo().intValue(), new Task(3, assignCommand));
            }
        }
    }

@@ -1740,9 +1907,10 @@
                            if (!result) {
                                throw new CoolException("更新plc站点信息失败");
                            }
                            wrkMast.setWrkSts(4L);
                            //任务号清零
                            liftProtocol.setTaskNo((short) 0);
                            wrkMast.setWrkSts(4L);
                            wrkMast.setLiftNo(null);//提升机解锁
                            break;
                        case 7://7.提升机迁移小车中 ==> 8.提升机迁移小车完成
                            if (liftProtocol.getLev().intValue() != lev) {
@@ -1764,6 +1932,7 @@
                            wrkMast.setWrkSts(34L);//34.出库完成，暂时先直接完成出库工作档，后续需要根据输送线给出的状态来确定34.出库完成状态
                            //任务号清零
                            liftProtocol.setTaskNo((short) 0);
                            wrkMast.setLiftNo(null);//提升机解锁
                            break;
                        default:
                    }
@@ -1811,8 +1980,11 @@
                if (liftProtocol.getAssignCommand() != null) {
                    //设置提升机为空闲状态
                    liftProtocol.setProtocolStatus(LiftProtocolStatusType.IDLE);
                    //任务号清零
                    liftProtocol.setTaskNo((short) 0);
                    //判断是否为四向穿梭车调度提升机，如是则无需清理任务号
                    if (!liftProtocol.getSecurityMk()) {
                        //任务号清零
                        liftProtocol.setTaskNo((short) 0);
                    }
                    //标记复位
                    liftProtocol.setPakMk(true);
                    //任务指令清零
@@ -2663,7 +2835,7 @@
                //小车已经达到提升机内

                //判断提升机是否处于空闲状态
                if (!liftProtocol.isIdle()) {
                if (!liftProtocol.isIdle(wrkCharge.getWrkNo().shortValue())) {
                    continue;
                }

@@ -2754,23 +2926,32 @@
            }else if (wrkCharge.getWrkSts() == 57) {//57.小车到达充电桩
                //充电中
                //判断小车是否充满电量，满电1000或电压54V以上
                if (shuttleProtocol.getBatteryPower() == null || shuttleProtocol.getCurrentVoltage() == null) {
                    continue;
                }
                if (shuttleProtocol.getBatteryPower() >= 1000 && shuttleProtocol.getCurrentVoltage() >= 54000) {
                    //充满，断开充电
                    List<ShuttleCommand> commands = new ArrayList<>();
                    ShuttleAssignCommand assignCommand = new ShuttleAssignCommand();
                    assignCommand.setShuttleNo(shuttleProtocol.getShuttleNo());
                    assignCommand.setTaskMode((short) 0);
                    assignCommand.setTaskNo(wrkCharge.getWrkNo().shortValue());
                    assignCommand.setCharge(true);
//                    List<ShuttleCommand> commands = new ArrayList<>();
//                    ShuttleAssignCommand assignCommand = new ShuttleAssignCommand();
//                    assignCommand.setShuttleNo(shuttleProtocol.getShuttleNo());
//                    assignCommand.setTaskMode((short) 0);
//                    assignCommand.setTaskNo(wrkCharge.getWrkNo().shortValue());
//                    assignCommand.setCharge(true);
//
//                    //创建充电指令
//                    ShuttleCommand command = shuttleThread.getChargeSwitchCommand((short) 2);//断开充电
//                    commands.add(command);
//
//                    //指令集分配
//                    assignCommand.setCommands(commands);
//
//                    shuttleProtocol.setProtocolStatus(ShuttleProtocolStatusType.CHARGING_WAITING);

                    //创建充电指令
                    ShuttleCommand command = shuttleThread.getChargeSwitchCommand((short) 2);//断开充电
                    commands.add(command);

                    //指令集分配
                    assignCommand.setCommands(commands);

                    shuttleProtocol.setProtocolStatus(ShuttleProtocolStatusType.CHARGING_WAITING);
                    //将小车移动到空闲的巷道
                    ShuttleAssignCommand assignCommand = Utils.searchEmptyGroupToMoveShuttle(Utils.getLev(shuttleProtocol.getLocNo()), shuttleProtocol.getShuttleNo().intValue(), shuttleThread, null);
                    if (assignCommand == null) {
                        continue;
                    }

                    wrkCharge.setWrkSts(60L);//60.充电任务完成
                    if (wrkChargeMapper.updateById(wrkCharge) > 0) {