充电任务

Junjie

2023-06-26 ea9caa1cc989e8b5166eafcf9174aae735dc19e8

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

@@ -4,12 +4,14 @@
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.core.common.Cools;
import com.core.common.SpringUtils;
import com.core.exception.CoolException;
import com.zy.asrs.entity.*;
import com.zy.asrs.mapper.*;
import com.zy.asrs.service.*;
import com.zy.asrs.utils.Utils;
import com.zy.common.model.*;
import com.zy.common.model.enums.NavigationMapType;
import com.zy.common.model.enums.WrkChargeType;
import com.zy.common.service.CommonService;
import com.zy.common.service.erp.ErpService;
@@ -569,7 +571,7 @@
                    //数据库中也不存在地图数据，从地图文件中获取
                    //载入地图
                    NavigateMapData mapData = new NavigateMapData(i);
                    List<List<MapNode>> lists = mapData.getJsonData(-1);//获取完整地图(包括入库出库)
                    List<List<MapNode>> lists = mapData.getJsonData(-1, null);//获取完整地图(包括入库出库)

                    //存入数据库
                    basMap = new BasMap();
@@ -683,6 +685,11 @@

                                //判断提升机是否空闲
                                if (!liftProtocol.isIdle()) {
                                    try {
                                        Thread.sleep(1000);//休眠1s
                                    } catch (InterruptedException e) {
                                        throw new RuntimeException(e);
                                    }
                                    continue;//提升机忙
                                }

@@ -694,7 +701,7 @@
                                    continue;//提升机不在目标楼层跳过
                                }

                                Integer staNo = Utils.levToOutInStaNo(lev);
                                Integer staNo = Utils.levToOutInStaNo(lev >= 2 ? lev + 1 : lev);
                                //获取目标站信息
                                StaProtocol staProtocol1 = devpThread.getStation().get(staNo);
                                if (staProtocol1 == null) {
@@ -742,16 +749,19 @@
                                //同一层直接取货无需经过提升机
                                //直接计算车到提升机取货再到库位路径指令
                                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);//站点号
                                    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, 1000);
                                    ShuttleCommand moveCommand = shuttleThread.getMoveCommand(startCode, distCode, 1400, runDirection, startCode, 1400, 500);
                                    commands.add(0, moveCommand);//将该指令添加到队头
                                }
                                assignCommand.setCommands(commands);
@@ -764,14 +774,17 @@
                                //不同层，将目标库位分配成提升机库位号

                                //小车移动到提升机口，计算路径
                                List<ShuttleCommand> commands = this.shuttleAssignCommand(currentLocNo, liftSiteLocNo, ShuttleTaskModeType.PAK_IN.id, assignCommand, shuttleThread);
                                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, 1000);
                                ShuttleCommand moveCommand = shuttleThread.getMoveCommand(endStartCode, liftProtocol.getBarcode(), 1400, ShuttleRunDirection.TOP.id, endStartCode, 1400, 500);
                                commands.add(moveCommand);

                                //分配目标库位
@@ -796,7 +809,7 @@

    }

    //获取起点-终点指令。mapType：0=>无货物地图，1=》携带货物出入库地图
    //获取起点-终点指令
    public synchronized List<ShuttleCommand> shuttleAssignCommand(String startLocNo, String locNo, Integer mapType, ShuttleAssignCommand assignCommand, ShuttleThread shuttleThread) {
        //获取小车移动速度
        BasShuttle basShuttle = basShuttleService.selectById(assignCommand.getShuttleNo());
@@ -864,7 +877,7 @@
        List<NavigateNode> allNode = new ArrayList<>();

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

        if (calc != null) {
@@ -898,7 +911,7 @@
        commands.add(shuttleThread.getPalletCommand((short) 1));

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

                        //判断提升机是否空闲
                        if (!liftProtocol.isIdle()) {
                            try {
                                Thread.sleep(1000);//休眠1s
                            } catch (InterruptedException e) {
                                throw new RuntimeException(e);
                            }
                            continue;//提升机忙
                        }

@@ -985,7 +1003,7 @@
                            continue;//提升机不在目标楼层跳过
                        }

                        Integer staNo = Utils.levToOutInStaNo(lev);
                        Integer staNo = Utils.levToOutInStaNo(lev >= 2 ? lev + 1 : lev);
                        DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, 1);
                        //获取目标站信息
                        StaProtocol staProtocol1 = devpThread.getStation().get(staNo);
@@ -1020,32 +1038,26 @@
                        continue;
                    }

                    wrkMast.setShuttleNo(shuttleProtocol.getShuttleNo().intValue());//给工作档分配四向穿梭车号
                    //源库位(小车当前位置)
                    String currentLocNo = shuttleProtocol.getCurrentLocNo();

                    //小车当前层高
                    Integer currentLev = Utils.getLev(currentLocNo);
                    //获取提升机
                    LiftSlave liftSlave = slaveProperties.getLift().get(0);
                    //当前楼层提升机输送站点库位号
                    String liftSiteLocNo = Utils.levToOutInStaLocNo(currentLev);

                    //分配任务号
                    shuttleProtocol.setTaskNo(wrkMast.getWrkNo().shortValue());
                    //分配源库位
                    shuttleProtocol.setSourceLocNo(currentLocNo);

                    ShuttleAssignCommand assignCommand = new ShuttleAssignCommand();
                    //四向穿梭车号
                    assignCommand.setShuttleNo(shuttleProtocol.getShuttleNo());
                    //任务号
                    assignCommand.setTaskNo(wrkMast.getWrkNo().shortValue());
                    //入出库模式
                    assignCommand.setTaskMode(ShuttleTaskModeType.PAK_OUT.id.shortValue());
                    assignCommand.setSourceLocNo(currentLocNo);

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

                        wrkMast.setShuttleNo(shuttleProtocol.getShuttleNo().intValue());//给工作档分配四向穿梭车号
                        //源库位(小车当前位置)
                        String currentLocNo = shuttleProtocol.getCurrentLocNo();

                        //小车当前层高
                        Integer currentLev = Utils.getLev(currentLocNo);
                        //当前楼层提升机输送站点库位号
                        String liftSiteLocNo = Utils.levToOutInStaLocNo(currentLev);

                        ShuttleAssignCommand assignCommand = new ShuttleAssignCommand();
                        //四向穿梭车号
                        assignCommand.setShuttleNo(shuttleProtocol.getShuttleNo());
                        //任务号
                        assignCommand.setTaskNo(wrkMast.getWrkNo().shortValue());
                        //入出库模式
                        assignCommand.setTaskMode(ShuttleTaskModeType.PAK_OUT.id.shortValue());
                        assignCommand.setSourceLocNo(currentLocNo);

                        //判断小车和库位是否在同一层
                        if (Boolean.parseBoolean(searchIdleShuttle.get("sameLay").toString())) {
                            //同一层(将小车移动到货物位置)
@@ -1054,54 +1066,115 @@
                                //未找到路径，等待下一次
                                continue;
                            }

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

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

                            //分配目标库位
                            shuttleProtocol.setLocNo(wrkMast.getSourceLocNo());
                            //分配任务号
                            shuttleProtocol.setTaskNo(wrkMast.getWrkNo().shortValue());
                            //分配源库位
                            shuttleProtocol.setSourceLocNo(currentLocNo);
                            //目标库位
                            assignCommand.setLocNo(wrkMast.getSourceLocNo());
                            assignCommand.setCommands(commands);
                            wrkMast.setWrkSts(26L);//小车搬运中

                            if (wrkMastMapper.updateById(wrkMast) > 0) {
                                //下发任务
                                MessageQueue.offer(SlaveType.Shuttle, assignCommand.getShuttleNo().intValue(), new Task(3, assignCommand));
                            }
                        }else {
                            //不同层，将目标库位分配成提升机库位号(将小车移动到提升机位置)

                            //小车到提升机口指令
                            List<ShuttleCommand> commands = this.shuttleAssignCommand(currentLocNo, liftSiteLocNo, ShuttleTaskModeType.PAK_IN.id, assignCommand, shuttleThread);
                            if (commands == null) {
                                if (!currentLocNo.equals(liftSiteLocNo)) {//当前位置也不在提升机口
                                    continue;//未找到路径
                                }
                                commands = new ArrayList<>();
                            }
                            shuttleProtocol.setLocNo(liftSiteLocNo);
                            //分配任务号
                            shuttleProtocol.setTaskNo(wrkMast.getWrkNo().shortValue());
                            //分配源库位
                            shuttleProtocol.setSourceLocNo(currentLocNo);

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

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

                            //目标库位
                            assignCommand.setLocNo(liftSiteLocNo);
                            assignCommand.setCommands(commands);
                            wrkMast.setWrkSts(22L);//小车迁移状态

                            if (wrkMastMapper.updateById(wrkMast) > 0) {
                                //下发任务
                                MessageQueue.offer(SlaveType.Shuttle, assignCommand.getShuttleNo().intValue(), new Task(3, assignCommand));
                            }
                        }
                    } else if (wrkMast.getWrkSts() == 25) {
                        List<ShuttleCommand> commands = this.shuttleAssignCommand(currentLocNo, wrkMast.getSourceLocNo(), liftSiteLocNo, assignCommand, shuttleThread);

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

                        //当前楼层提升机输送站点库位号
                        String liftSiteLocNo = Utils.levToOutInStaLocNo(liftProtocol.getLev().intValue());

                        ShuttleAssignCommand assignCommand = new ShuttleAssignCommand();
                        //四向穿梭车号
                        assignCommand.setShuttleNo(shuttleProtocol.getShuttleNo());
                        //任务号
                        assignCommand.setTaskNo(wrkMast.getWrkNo().shortValue());
                        //入出库模式
                        assignCommand.setTaskMode(ShuttleTaskModeType.PAK_OUT.id.shortValue());
                        assignCommand.setSourceLocNo(liftSiteLocNo);

                        List<ShuttleCommand> commands = this.shuttleAssignCommand(liftSiteLocNo, wrkMast.getSourceLocNo(), liftSiteLocNo, assignCommand, shuttleThread);
                        if (commands == null) {
                            continue;//未找到路径
                        }
                        //此时车在提升机内部，需要多下达一步指令让车移动到提升机口
                        BasDevp basDevp = basDevpService.selectById(109);//获取提升机信息
                        short startCode = Short.parseShort(basDevp.getQrCodeValue());//提升机二维码
                        short startCode = liftProtocol.getBarcode();//提升机内部二维码
                        Short distCode = commands.get(0).getStartCodeNum();//目标二维码
                        //获取移动命令
                        ShuttleCommand moveCommand = shuttleThread.getMoveCommand(startCode, distCode, 1300, commands.get(0).getRunDirection(), (short) 1, 0);
                        ShuttleCommand moveCommand = shuttleThread.getMoveCommand(startCode, distCode, 1400, commands.get(0).getRunDirection(), startCode, 1400, 500);
                        commands.add(0, moveCommand);//将该指令添加到队头

                        //分配目标库位
                        shuttleProtocol.setLocNo(wrkMast.getSourceLocNo());
                        //分配任务号
                        shuttleProtocol.setTaskNo(wrkMast.getWrkNo().shortValue());
                        //分配源库位
                        shuttleProtocol.setSourceLocNo(liftSiteLocNo);
                        //目标库位
                        assignCommand.setLocNo(wrkMast.getSourceLocNo());
                        assignCommand.setCommands(commands);
                        wrkMast.setWrkSts(26L);//小车搬运中

                        if (wrkMastMapper.updateById(wrkMast) > 0) {
                            //下发任务
                            MessageQueue.offer(SlaveType.Shuttle, assignCommand.getShuttleNo().intValue(), new Task(3, assignCommand));
                        }
                    }

                    if (wrkMastMapper.updateById(wrkMast) > 0) {
                        //下发任务
                        MessageQueue.offer(SlaveType.Shuttle, assignCommand.getShuttleNo().intValue(), new Task(3, assignCommand));
                    }
                }
            }
        }
@@ -1132,6 +1205,9 @@
            }

            String shuttleLocNo = shuttleProtocol.getCurrentLocNo();//二维码对应库位号
            if (shuttleLocNo == null) {
                continue;
            }
            int shuttleLocNoLey = Utils.getLev(shuttleLocNo);//库位号对应层高
            if (lev == shuttleLocNoLey) {
                //工作档楼层相同的穿梭车
@@ -1140,49 +1216,7 @@
                //工作档不同楼层的穿梭车
                diffLev.add(shuttleThread);
            }
//
//            //更新当前最近的四向穿梭车
//            if (recentShuttle == null) {
//                recentShuttle = shuttleThread;
//            }else {
//                ShuttleProtocol recentShuttleProtocol = recentShuttle.getShuttleProtocol();//目前最近穿梭车
//                String recentShuttleLocNo = recentShuttleProtocol.getCurrentLocNo();//二维码对应库位号
//                String recentShuttleLocNoLay = recentShuttleLocNo.substring(recentShuttleLocNo.length() - 2, recentShuttleLocNo.length());//库位号对应层高
//
//                int recentShuttleLocNoLayInt = Integer.parseInt(recentShuttleLocNoLay);
//                int i = Math.abs(lev - recentShuttleLocNoLayInt);//工作档楼层减最近穿梭车楼层，取绝对值
//                int j = Math.abs(lev - shuttleLocNoLey);//工作档楼层减当前穿梭车楼层，取绝对值
//                if (i < j) {
//                    //更新最近穿梭车
//                    recentShuttle = shuttleThread;
//                } else if (i == j) {
//                    //楼层相同情况
//                    //找距离出库点最近的车
//
//                    if (!(recentShuttleProtocol.isIdle() && shuttleProtocol.isIdle())) {
//                        //只要有一辆车不是空闲则不进行调度
//                        map.put("sameLay", false);//不同层
//                        map.put("result", null);
//                        return map;
//                    }
//
//                    //获取提升机
//                    LiftSlave liftSlave = slaveProperties.getLift().get(0);
//                    //提升机库位号
//                    String recentLiftLocNo = liftSlave.getLiftLocNo(recentShuttleLocNoLayInt);
//                    String shuttleLiftLocNo = liftSlave.getLiftLocNo(shuttleLocNoLey);
//
//                    //当前最近四向穿梭车到提升机路径
//                    List<NavigateNode> recentShuttlePath = NavigateUtils.calc(recentShuttleLocNo, recentLiftLocNo, ShuttleTaskModeType.PAK_IN.id);
//                    //当前楼层四向穿梭车到提升机路径
//                    List<NavigateNode> shuttlePath = NavigateUtils.calc(shuttleLocNo, shuttleLiftLocNo, ShuttleTaskModeType.PAK_IN.id);
//                    //判断哪一个路径最短
//                    if (shuttlePath.size() < recentShuttlePath.size()) {
//                        //如果当前楼层的车路径更小，则更新最近穿梭车
//                        recentShuttle = shuttleThread;
//                    }
//                }
//            }

        }

        if (sameLev.size() > 0) {
@@ -1209,9 +1243,9 @@
                String recentLocNo = recentShuttle.getShuttleProtocol().getCurrentLocNo();

                //当前最近四向穿梭车到目标地点距离
                List<NavigateNode> recentShuttlePath = NavigateUtils.calc(recentLocNo, distLocNo, ShuttleTaskModeType.PAK_IN.id);
                List<NavigateNode> recentShuttlePath = NavigateUtils.calc(recentLocNo, distLocNo, NavigationMapType.NORMAL.id);//搜索空闲穿梭车，使用正常通道地图
                //当前穿梭车线程到目标地点距离
                List<NavigateNode> currentShuttlePath = NavigateUtils.calc(currentLocNo, distLocNo, ShuttleTaskModeType.PAK_IN.id);
                List<NavigateNode> currentShuttlePath = NavigateUtils.calc(currentLocNo, distLocNo, NavigationMapType.NORMAL.id);//搜索空闲穿梭车，使用正常通道地图
                if (recentShuttlePath == null || currentShuttlePath == null) {
                    continue;
                }
@@ -1241,9 +1275,9 @@
                int recentLev = Utils.getLev(recentLocNo);

                //当前最近四向穿梭车到当前车子所在楼层的提升机口距离
                List<NavigateNode> recentShuttlePath = NavigateUtils.calc(recentLocNo, Utils.levToOutInStaLocNo(recentLev), ShuttleTaskModeType.PAK_IN.id);
                List<NavigateNode> recentShuttlePath = NavigateUtils.calc(recentLocNo, Utils.levToOutInStaLocNo(recentLev), NavigationMapType.NORMAL.id);//搜索空闲穿梭车，使用正常通道地图
                //当前穿梭车线程到当前车子所在楼层的提升机口距离
                List<NavigateNode> currentShuttlePath = NavigateUtils.calc(currentLocNo, Utils.levToOutInStaLocNo(currentLev), ShuttleTaskModeType.PAK_IN.id);
                List<NavigateNode> currentShuttlePath = NavigateUtils.calc(currentLocNo, Utils.levToOutInStaLocNo(currentLev), NavigationMapType.NORMAL.id);//搜索空闲穿梭车，使用正常通道地图
                if (recentShuttlePath == null || currentShuttlePath == null) {
                    continue;
                }
@@ -1330,10 +1364,8 @@
                            wrkCharge.setWrkSts(53L);//迁移完成
                            shuttleProtocol.setProtocolStatus(ShuttleProtocolStatusType.CHARGING);
                            break;
                        case 56:
                            if (shuttleProtocol.getBatteryPower() == 1000) {
                                wrkCharge.setWrkSts(60L);//充电完成
                            }
                        case 56://小车去充电桩中
                            wrkCharge.setWrkSts(57L);//到达充电桩
                            break;
                        default:
                    }
@@ -1343,16 +1375,18 @@
                            //设置四向穿梭车为空闲状态
                            shuttleProtocol.setProtocolStatus(ShuttleProtocolStatusType.IDLE);
                        }
                        //任务号清零
                        shuttleProtocol.setTaskNo((short) 0);
                        //源库位清零
                        shuttleProtocol.setSourceLocNo(null);
                        //目标库位清零
                        shuttleProtocol.setLocNo(null);
                        //标记复位
                        shuttleProtocol.setPakMk(true);
                        //任务指令清零
                        shuttleProtocol.setAssignCommand(null);
                        if (wrkCharge.getWrkSts() != 57) {
                            //任务号清零
                            shuttleProtocol.setTaskNo((short) 0);
                            //源库位清零
                            shuttleProtocol.setSourceLocNo(null);
                            //目标库位清零
                            shuttleProtocol.setLocNo(null);
                            //标记复位
                            shuttleProtocol.setPakMk(true);
                            //任务指令清零
                            shuttleProtocol.setAssignCommand(null);
                        }
                        News.info("四向穿梭车已确认且任务完成状态,复位。四向穿梭车号={}", shuttleProtocol.getShuttleNo());
                    } else {
                        News.error("四向穿梭车已确认且任务完成状态,复位失败，但未找到工作档。四向穿梭车号={}，工作号={}", shuttleProtocol.getShuttleNo(), shuttleProtocol.getTaskNo());
@@ -1388,11 +1422,6 @@
                continue;
            }

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

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

@@ -1410,14 +1439,13 @@
                //工作档目标库位楼层
                int wrkMastLocNoLey = Utils.getLev(wrkMastLocNo);

                //提升机当前楼层
                int liftLev = liftProtocol.getLev().intValue();
                if (liftLev == 0) {//提升机当前楼层为0，提升机失去位置信息，让提升机前往一楼
                    LiftCommand command = liftThread.getLiftUpDownCommand(liftProtocol.getLiftNo(), liftProtocol.getTaskNo(), LiftLevType.ONE.lev);
                    commands.add(command);//将命令添加进list
                Integer levTmp = wrkMastLocNoLey;
                if (wrkMastLocNoLey >= 2) {
                    levTmp += 1;
                }
                Integer distStaNo = Utils.levToOutInStaNo(levTmp);

                if (liftLev != LiftLevType.TWO.realLev) {
                if (liftProtocol.getPositionArrivalFeedback().intValue() != LiftLevType.TWO.realLev.intValue()) {
                    //提升机不在输送线楼层，获取到输送线层的提升机命令
                    LiftCommand command1 = liftThread.getLiftUpDownCommand(liftProtocol.getLiftNo(), liftProtocol.getTaskNo(), LiftLevType.TWO.lev);
                    commands.add(command1);//将命令添加进list
@@ -1428,12 +1456,8 @@
                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;
                }

                //提升机前往目标楼层(工作档目标楼层)
                LiftCommand command3 = liftThread.getLiftUpDownCommand(liftProtocol.getLiftNo(), liftProtocol.getTaskNo(), levTmp);
@@ -1442,30 +1466,57 @@
                //提升机到达指定楼层，输送线将货物移出去(正转)
                //输送线将货物移出去
                LiftCommand command4 = liftThread.getLiftTurnCommand(liftProtocol.getLiftNo(), liftProtocol.getTaskNo(), 1);
                Integer distStaNo = Utils.levToOutInStaNo(levTmp);
                command4.setOperaStaNo(distStaNo.shortValue());//操作目标楼层站点
                command4.setRotationDire(1);//给输送线下发链条转动信号，正转
                command4.setDevpId(devpId);
                command4.setStaNo(distStaNo.shortValue());//设置目标站
                commands.add(command4);//将命令添加进list

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

                wrkMast.setWrkSts(3L);//3.提升机搬运中
            } else if (wrkMast.getWrkSts() == 6) {//6.迁移小车至提升机口完成 => 7.提升机迁移小车中
                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;//小车当前二维码和提升机内部二维码不一致，不允许执行
                }

                //工作档目标库位号
                String wrkMastLocNo = wrkMast.getIoType() == 101 ? wrkMast.getSourceLocNo() : wrkMast.getLocNo();
                String wrkMastLocNo = wrkMast.getLocNo();
                //工作档目标库位楼层
                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(7L);//6.迁移小车至提升机口完成 => 7.提升机迁移小车中
            } else if(wrkMast.getWrkSts() == 23) {//23.迁移小车至提升机口完成 => 24.提升机迁移小车中
                liftProtocol.setShuttleNo(wrkMast.getShuttleNo().shortValue());//设置四向穿梭车号

                //找到四向穿梭车的线程
                //判断小车是否在提升机内，且处于空闲状态
                ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, wrkMast.getShuttleNo());
                if (shuttleThread == null) {
                    continue;
@@ -1475,44 +1526,28 @@
                    continue;
                }

                //当前穿梭车库位号
                String currentLocNo = shuttleProtocol.getCurrentLocNo();
                //当前穿梭车楼层
                int currentLocNoLey = Utils.getLev(currentLocNo);
                if (!shuttleProtocol.isIdle()) {
                    continue;//小车状态忙
                }
                if (shuttleProtocol.getCurrentCode().intValue() != liftProtocol.getBarcode().intValue()) {
                    continue;//小车当前二维码和提升机内部二维码不一致，不允许执行
                }

                //工作档目标库位号
                String wrkMastLocNo = wrkMast.getIoType() == 101 ? wrkMast.getSourceLocNo() : wrkMast.getLocNo();
                String wrkMastLocNo = wrkMast.getSourceLocNo();
                //工作档目标库位楼层
                int wrkMastLocNoLey = Utils.getLev(wrkMastLocNo);

                //提升机当前楼层
                int liftLev = liftProtocol.getLev().intValue();
                if (liftLev == 0) {//提升机当前楼层为0，提升机失去位置信息，让提升机前往一楼
                    LiftCommand command = liftThread.getLiftUpDownCommand(liftProtocol.getLiftNo(), liftProtocol.getTaskNo(), LiftLevType.ONE.lev);
                    commands.add(command);//将命令添加进list
                if (wrkMastLocNoLey >= 2) {
                    wrkMastLocNoLey++;
                }

                if (liftLev != currentLocNoLey) {
                    //不同楼层
                    //获取目标楼层(穿梭车所在楼层)命令
                    LiftCommand command1 = liftThread.getLiftUpDownCommand(liftProtocol.getLiftNo(), liftProtocol.getTaskNo(), currentLocNoLey);
                    commands.add(command1);//将命令添加进list
                }
                //提升机前往目标楼层(工作档目标楼层)
                LiftCommand command1 = liftThread.getLiftUpDownCommand(liftProtocol.getLiftNo(), liftProtocol.getTaskNo(), wrkMastLocNoLey);
                commands.add(command1);//将命令添加进list

                //输送线将四向穿梭车移动进来(反转)
                LiftCommand command2 = liftThread.getLiftTurnCommand(liftProtocol.getLiftNo(), liftProtocol.getTaskNo(), 4);
                commands.add(command2);//将命令添加进list

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

                //提升机到达指定楼层，输送线将四向穿梭车移出去
                //输送线将四向穿梭车移动出去(正转)
                LiftCommand command4 = liftThread.getLiftTurnCommand(liftProtocol.getLiftNo(), liftProtocol.getTaskNo(), 1);
                commands.add(command4);//将命令添加进list
                //给提升机分配任务
                liftProtocol.setTaskNo(wrkMast.getWrkNo().shortValue());//设置任务号
                liftProtocol.setProtocolStatus(LiftProtocolStatusType.WORKING);//设置提升机状态为工作中

                wrkMast.setWrkSts(24L);//23.迁移小车至提升机口完成 => 24.提升机迁移小车中
            } else if (wrkMast.getWrkSts() == 27) {//27.小车出库搬运完成
@@ -1523,14 +1558,10 @@

                //提升机当前楼层
                int liftLev = liftProtocol.getLev().intValue();
                if (liftLev == 0) {//提升机当前楼层为0，提升机失去位置信息，让提升机前往一楼
                    LiftCommand command = liftThread.getLiftUpDownCommand(liftProtocol.getLiftNo(), liftProtocol.getTaskNo(), LiftLevType.ONE.lev);
                    commands.add(command);//将命令添加进list
                }

                //判断提升机是否到位
                StaProtocol staProtocol = devpThread.getStation().get(Utils.levToOutInStaNo(wrkMastLocNoLey));//起始站点
                if (liftLev != wrkMastLocNoLey && wrkMastLocNoLey != 1 || !staProtocol.isLiftArrival()) {
                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
@@ -1563,6 +1594,10 @@
                command5.setStaNo((short) 104);//写入出库目标站104
                command5.setRotationDire(0);//链条转动停止
                commands.add(command5);

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

                wrkMast.setWrkSts(28L);//28.提升机搬运中
            }
@@ -1648,6 +1683,31 @@
                    }
                }

                //查询是否有充电任务
                WrkCharge wrkCharge = wrkChargeMapper.selectByWorkNo(liftProtocol.getTaskNo().intValue());
                if (wrkCharge != null) {
                    switch (wrkCharge.getWrkSts().intValue()) {
                        case 54://提升机搬运中
                            wrkCharge.setWrkSts(55L);//提升机搬运完成
                            break;
                        default:
                    }

                    if (wrkChargeMapper.updateById(wrkCharge) > 0) {
                        //设置提升机为空闲状态
                        liftProtocol.setProtocolStatus(LiftProtocolStatusType.IDLE);
                        //任务号清零
                        liftProtocol.setTaskNo((short) 0);
                        //标记复位
                        liftProtocol.setPakMk(true);
                        //任务指令清零
                        liftProtocol.setAssignCommand(null);
                        News.info("提升机已确认且任务完成状态,复位。提升机号={}", liftProtocol.getLiftNo());
                    } else {
                        News.error("提升机已确认且任务完成状态,复位失败，但未找到工作档。提升机号={}，工作号={}", liftProtocol.getLiftNo(), liftProtocol.getTaskNo());
                    }
                }

                //不是入出库调度任务、工作档任务，进行提升机的复位
                if (liftProtocol.getAssignCommand() != null) {
                    //设置提升机为空闲状态
@@ -1659,11 +1719,6 @@
                    //任务指令清零
                    liftProtocol.setAssignCommand(null);
                    News.info("提升机已确认且任务完成状态,复位。提升机号={}", liftProtocol.getLiftNo());
//                    LiftAssignCommand assignCommand = liftProtocol.getAssignCommand();
//                    if (!assignCommand.getAuto()) {
//                        //手动命令
//
//                    }
                }

            }
@@ -2339,111 +2394,244 @@
     * 四向穿梭车电量检测 ===>> 发起充电
     */
    public synchronized void loopShuttleCharge() {
        for (DevpSlave devpSlave : slaveProperties.getDevp()) {
            SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, devpSlave.getId());
            for (ShuttleSlave shuttle : slaveProperties.getShuttle()) {
                //获取四向穿梭车线程
                ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, shuttle.getId());
                ShuttleProtocol shuttleProtocol = shuttleThread.getShuttleProtocol();
                if (shuttleProtocol == null) {
                    continue;
                }

                //判断当前小车是否满足需要充电要求
                if (!shuttleProtocol.isRequireCharge()) {
                    continue;
                }

                WrkCharge wrkCharge = wrkChargeService.selectWorking(null, WrkChargeType.charge);
                if (wrkCharge != null) {//已有充电任务
                    continue;
                }

                ShuttleChargeType shuttleCharge = null;
                String locNo;
                for (ShuttleChargeType chargeType : ShuttleChargeType.values()) {
                    switch (chargeType.id) {
                        case 1:
                            if (devpThread.charge0 == false) {
                                ShuttleChargeType first = ShuttleChargeType.FIRST;
                                locNo = first.locNo;
                                if (wrkChargeService.selectWorkingOfCharge(first.id) == null) {
                                    shuttleCharge = first;
                                }
                            }
                            break;
                        default:
                    }
                }

                if (shuttleCharge == null) {
                    continue;
                }

                String chargeLocNo = shuttleCharge.locNo;
                wrkCharge = new WrkCharge();
                wrkCharge.setShuttleNo(shuttle.getId());
                wrkCharge.setCharge(shuttleCharge.id);
                wrkCharge.setWrkNo(commonService.getChargeWorkNo(4));
                wrkCharge.setWrkSts(51L);   // 21.准备充电
                wrkCharge.setIoPri((double) 10);
                wrkCharge.setLocNo(chargeLocNo);
                wrkCharge.setMemo("charge");
                wrkCharge.setAppeTime(new Date());
                if (!wrkChargeService.insert(wrkCharge)) {
                    News.error("保存{}号四向穿梭车充电任务失败!!!", shuttle.getId());
                    continue;
                }

                shuttleProtocol.setProtocolStatus(ShuttleProtocolStatusType.CHARGING);//充电中
                News.info("保存{}号四向穿梭车充电任务成功!!!", shuttle.getId());
        for (ShuttleSlave shuttle : slaveProperties.getShuttle()) {
            //获取四向穿梭车线程
            ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, shuttle.getId());
            ShuttleProtocol shuttleProtocol = shuttleThread.getShuttleProtocol();
            if (shuttleProtocol == null) {
                continue;
            }

            //判断当前小车是否满足需要充电要求
            if (!shuttleProtocol.isRequireCharge()) {
                continue;
            }

            WrkCharge wrkCharge = wrkChargeService.selectWorking(shuttleProtocol.getShuttleNo().intValue(), WrkChargeType.charge);
            if (wrkCharge != null) {//已有充电任务
                continue;
            }

            ShuttleChargeType shuttleCharge = null;
            for (ShuttleChargeType chargeType : ShuttleChargeType.values()) {
                if (wrkChargeService.selectWorkingOfCharge(chargeType.id) == null) {
                    shuttleCharge = chargeType;
                    break;
                }
            }

            if (shuttleCharge == null) {
                continue;
            }

            String chargeLocNo = shuttleCharge.locNo;
            wrkCharge = new WrkCharge();
            wrkCharge.setShuttleNo(shuttle.getId());
            wrkCharge.setCharge(shuttleCharge.id);
            wrkCharge.setWrkNo(commonService.getChargeWorkNo(4));
            wrkCharge.setWrkSts(51L);   // 21.准备充电
            wrkCharge.setIoPri((double) 10);
            wrkCharge.setLocNo(chargeLocNo);
            wrkCharge.setMemo("charge");
            wrkCharge.setAppeTime(new Date());
            if (!wrkChargeService.insert(wrkCharge)) {
                News.error("保存{}号四向穿梭车充电任务失败!!!", shuttle.getId());
                continue;
            }

            shuttleProtocol.setProtocolStatus(ShuttleProtocolStatusType.CHARGING);//充电中
            News.info("保存{}号四向穿梭车充电任务成功!!!", shuttle.getId());
        }


    }

    /**
     * 执行四向穿梭车充电任务
     */
    public synchronized void executeShuttleCharge() {
        WrkCharge wrkCharge = wrkChargeService.selectWorking(null, WrkChargeType.charge);
        if (wrkCharge == null) {
            return;
        }
        for (ShuttleSlave shuttle : slaveProperties.getShuttle()) {
            WrkCharge wrkCharge = wrkChargeService.selectWorking(null, WrkChargeType.charge);
            if (wrkCharge == null) {
                continue;
            }

            ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, wrkCharge.getShuttleNo());
            if (shuttleThread == null) {
                continue;
            }
            ShuttleProtocol shuttleProtocol = shuttleThread.getShuttleProtocol();
            if (shuttleProtocol == null) {
                continue;
            }

        ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, wrkCharge.getShuttleNo());
        if (shuttleThread == null) {
            return;
        }
        ShuttleProtocol shuttleProtocol = shuttleThread.getShuttleProtocol();
        if (shuttleProtocol == null) {
            return;
        }
            //获取提升机
            LiftThread liftThread = (LiftThread) SlaveConnection.get(SlaveType.Lift, 1);
            if (liftThread == null) {
                continue;
            }
            LiftProtocol liftProtocol = liftThread.getLiftProtocol();
            if (liftProtocol == null) {
                continue;
            }
            //充电库位号
            String chargeLocNo = wrkCharge.getLocNo();
            //充电库位层高
            Integer chargeLocNoLev = Utils.getLev(chargeLocNo);

        //当前穿梭车库位号
        String currentLocNo = shuttleProtocol.getCurrentLocNo();
        //小车当前层高
        Integer currentLev = currentLocNo == null ? 0 : Integer.parseInt(currentLocNo.substring(currentLocNo.length() - 2, currentLocNo.length()));
        //获取提升机
        LiftSlave liftSlave = slaveProperties.getLift().get(0);
        //提升机库位号
        String liftLocNo = liftSlave.getLiftLocNo(currentLev);
        //充电库位号
        String chargeLocNo = wrkCharge.getLocNo();
        //充电库位层高
        Integer chargeLocNoLev = Integer.parseInt(chargeLocNo.substring(chargeLocNo.length() - 2, chargeLocNo.length()));
            if (wrkCharge.getWrkSts() == 51) {
                //当前穿梭车库位号
                String currentLocNo = shuttleProtocol.getCurrentLocNo();
                if (currentLocNo == null) {
                    continue;
                }
                //小车当前层高
                Integer currentLev = Utils.getLev(currentLocNo);

        if (wrkCharge.getWrkSts() == 51 || wrkCharge.getWrkSts() == 55) {
            if (currentLev == chargeLocNoLev) {
                //同一层无需经过提升机
                if (currentLev == chargeLocNoLev) {
                    //同一层无需经过提升机
                    //直接计算车到充电库位

                    ShuttleAssignCommand assignCommand = new ShuttleAssignCommand();

                    //获取小车到充电库位路径指令
                    List<ShuttleCommand> commands = this.shuttleAssignCommand(currentLocNo, chargeLocNo, NavigationMapType.NONE.id, assignCommand, shuttleThread);
                    if (commands == null) {
                        continue;//未找到路径
                    }
                    //进行充电中
                    shuttleProtocol.setProtocolStatus(ShuttleProtocolStatusType.CHARGING);

                    assignCommand.setShuttleNo(shuttleProtocol.getShuttleNo());
                    assignCommand.setTaskMode((short) 9);//充电
                    assignCommand.setTaskNo(wrkCharge.getWrkNo().shortValue());
                    assignCommand.setCharge(true);//充电任务

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

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

                    wrkCharge.setWrkSts(56L);//充电中状态
                    if (wrkChargeMapper.updateById(wrkCharge) > 0) {
                        //下发任务
                        MessageQueue.offer(SlaveType.Shuttle, assignCommand.getShuttleNo().intValue(), new Task(3, assignCommand));
                    }
                }else {
                    //不同层，调度小车到充电桩目标层

                    ShuttleAssignCommand assignCommand = new ShuttleAssignCommand();

                    //获取小车当前楼层的站点号
                    String liftSiteLocNo = Utils.levToOutInStaLocNo(currentLev);

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

                    //获取当前小车所在楼层的站点信息
                    BasDevp basDevp = basDevpService.queryByLocNo(liftSiteLocNo);
                    if (basDevp == null) {
                        continue;//找不到站点信息
                    }
                    Short basDevpQrCode = Short.parseShort(basDevp.getQrCodeValue());//站点二维码

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

                    //分配目标库位
                    shuttleProtocol.setLocNo(chargeLocNo);
                    assignCommand.setShuttleNo(shuttleProtocol.getShuttleNo());
                    assignCommand.setTaskMode((short) 9);//充电
                    assignCommand.setTaskNo(wrkCharge.getWrkNo().shortValue());
                    assignCommand.setCharge(true);//充电任务
                    //目标库位
                    assignCommand.setLocNo(chargeLocNo);
                    //源库位
                    assignCommand.setSourceLocNo(currentLocNo);
                    assignCommand.setCommands(commands);
                    wrkCharge.setWrkSts(52L);//小车迁移状态
                    if (wrkChargeMapper.updateById(wrkCharge) > 0) {
                        //下发任务
                        MessageQueue.offer(SlaveType.Shuttle, assignCommand.getShuttleNo().intValue(), new Task(3, assignCommand));
                    }
                }

            }else if(wrkCharge.getWrkSts() == 53){
                //小车已经达到提升机内

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

                //判断小车是否在提升机内
                if (shuttleProtocol.getCurrentCode().intValue() != liftProtocol.getBarcode().intValue()) {
                    //小车不在提升机内
                    continue;
                }

                //给提升机分配任务
                liftProtocol.setTaskNo(wrkCharge.getWrkNo().shortValue());//设置任务号
                liftProtocol.setShuttleNo(wrkCharge.getShuttleNo().shortValue());//设置四向穿梭车号
                liftProtocol.setProtocolStatus(LiftProtocolStatusType.WORKING);//设置提升机状态为工作中

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

                //提升机前往目标楼层
                //获取充电库位目标楼层命令
                LiftCommand command1 = liftThread.getLiftUpDownCommand(liftProtocol.getLiftNo(), liftProtocol.getTaskNo(), chargeLocNoLev >= 2 ? chargeLocNoLev + 1 : chargeLocNoLev);
                commands.add(command1);//将命令添加进list

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

            }else if(wrkCharge.getWrkSts() == 55){//55.提升机迁移小车完成
                //直接计算车到充电库位

                ShuttleAssignCommand assignCommand = new ShuttleAssignCommand();

                //获取小车到充电库位路径指令
                List<ShuttleCommand> commands = this.shuttleAssignCommand(currentLocNo, chargeLocNo, ShuttleTaskModeType.PAK_IN.id, assignCommand, shuttleThread);
                Short liftLev = liftProtocol.getLev();
                if (liftLev == null) {
                    continue;
                }
                //判断提升机楼层是否到达目标楼层
                if (liftLev.intValue() != chargeLocNoLev) {
                    continue;//没有到达目标楼层
                }

                //此时车在提升机内部，下达一步指令让车移动到提升机口
                Integer staNo = Utils.levToOutInStaNo(liftLev >= 2 ? liftLev + 1 : liftLev);//站点号
                BasDevp basDevp = basDevpService.selectById(staNo);
                if (basDevp == null) {
                    continue;//站点不存在
                }

                //获取提升机口到充电库位路径指令
                List<ShuttleCommand> commands = this.shuttleAssignCommand(basDevp.getLocNo(), chargeLocNo, NavigationMapType.NONE.id, assignCommand, shuttleThread);
                if (commands == null) {
                    continue;//未找到路径
                }

                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);//将该指令添加到队头

                //进行充电中
                shuttleProtocol.setProtocolStatus(ShuttleProtocolStatusType.CHARGING);

@@ -2464,118 +2652,33 @@
                    //下发任务
                    MessageQueue.offer(SlaveType.Shuttle, assignCommand.getShuttleNo().intValue(), new Task(3, assignCommand));
                }
            }else {
                //不同层，将目标库位分配成提升机库位号
            }else if (wrkCharge.getWrkSts() == 57) {//57.小车到达充电桩
                //充电中
                //判断小车是否充满电量，满电1000或电压54V以上
                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);

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

                //小车移动到提升机口，计算路径
                List<ShuttleCommand> commands = this.shuttleAssignCommand(currentLocNo, liftLocNo, ShuttleTaskModeType.PAK_IN.id, assignCommand, shuttleThread);
                //分配目标库位
                shuttleProtocol.setLocNo(liftLocNo);
                    //指令集分配
                    assignCommand.setCommands(commands);


                assignCommand.setShuttleNo(shuttleProtocol.getShuttleNo());
                assignCommand.setTaskMode((short) 9);//充电
                assignCommand.setTaskNo(wrkCharge.getWrkNo().shortValue());
                assignCommand.setCharge(true);//充电任务
                //目标库位
                assignCommand.setLocNo(liftLocNo);
                //源库位
                assignCommand.setSourceLocNo(currentLocNo);
                assignCommand.setCommands(commands);
                wrkCharge.setWrkSts(52L);//小车迁移状态
                if (wrkChargeMapper.updateById(wrkCharge) > 0) {
                    shuttleProtocol.setProtocolStatus(ShuttleProtocolStatusType.CHARGING_WAITING);
                    //下发任务
                    MessageQueue.offer(SlaveType.Shuttle, assignCommand.getShuttleNo().intValue(), new Task(3, assignCommand));
                }
            }

        }else if(wrkCharge.getWrkSts() == 53){
            //小车已经达到提升机口
            LiftThread liftThread = (LiftThread) SlaveConnection.get(SlaveType.Lift, liftSlave.getId());
            if (liftThread == null) {
                return;
            }
            LiftProtocol liftProtocol = liftThread.getLiftProtocol();
            if (liftProtocol == null) {
                return;
            }

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

            //给提升机分配任务
            liftProtocol.setLiftLock(true);//锁定提升机
            liftProtocol.setTaskNo(wrkCharge.getWrkNo().shortValue());//设置任务号
            liftProtocol.setShuttleNo(wrkCharge.getShuttleNo().shortValue());//设置四向穿梭车号
            liftProtocol.setProtocolStatus(LiftProtocolStatusType.WORKING);//设置提升机状态为工作中

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

            //提升机当前楼层
            int liftLev = liftProtocol.getLev().intValue();
            if (liftLev != currentLev) {
                //穿梭车和提升机处于不同楼层
                //获取目标楼层(穿梭车所在楼层)命令
                LiftCommand command1 = liftThread.getLiftUpDownCommand(liftProtocol.getLiftNo(), liftProtocol.getTaskNo(), currentLev);
                commands.add(command1);//将命令添加进list
            }

            //输送线将四向穿梭车移动进来(正转)
            LiftCommand command2 = liftThread.getLiftTurnCommand(liftProtocol.getLiftNo(), liftProtocol.getTaskNo(), 1);
            commands.add(command2);//将命令添加进list

            //提升机前往目标楼层
            //获取充电库位目标楼层命令
            LiftCommand command3 = liftThread.getLiftUpDownCommand(liftProtocol.getLiftNo(), liftProtocol.getTaskNo(), chargeLocNoLev);
            commands.add(command3);//将命令添加进list

            //提升机到达指定楼层，输送线将四向穿梭车移出去
            //输送线将四向穿梭车移动出去(反转)
            LiftCommand command4 = liftThread.getLiftTurnCommand(liftProtocol.getLiftNo(), liftProtocol.getTaskNo(), 2);
            commands.add(command4);//将命令添加进list

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

        } else if (wrkCharge.getWrkSts() == 56) {
            //充电中
            //判断小车是否充满电量，满电1000或电压54V以上
            if (shuttleProtocol.getBatteryPower() >= 1000 || shuttleProtocol.getCurrentVoltage() >= 540) {
                //充满，断开充电
                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);
                //下发任务
                MessageQueue.offer(SlaveType.Shuttle, assignCommand.getShuttleNo().intValue(), new Task(3, assignCommand));
            }

            if (shuttleProtocol.getProtocolStatus() == ShuttleProtocolStatusType.CHARGING_WAITING.id) {
                shuttleProtocol.setProtocolStatus(ShuttleProtocolStatusType.CHARGING);
                if (shuttleProtocol.getProtocolStatus() == ShuttleProtocolStatusType.CHARGING_WAITING.id) {
                    shuttleProtocol.setProtocolStatus(ShuttleProtocolStatusType.CHARGING);
                }
            }
        }