#

tqs

2022-12-23 eb96c650d25d9d17ea3c582cd091dbeff9909bf1

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

@@ -63,6 +63,8 @@
    @Autowired
    private WrkMastMapper wrkMastMapper;
    @Autowired
    private WrkMastService wrkMastService;
    @Autowired
    private WrkDetlService wrkDetlService;
    @Autowired
    private LocMastService locMastService;
@@ -95,8 +97,7 @@
     * 组托
     * 入库站，根据条码扫描生成入库工作档，工作状态 2
     */
    @Async
    public void generateStoreWrkFile() {
    public synchronized void generateStoreWrkFile() {
        // 根据输送线plc遍历
        for (DevpSlave devp : slaveProperties.getDevp()) {
            // 遍历入库口
@@ -228,8 +229,7 @@
     * wms入库
     * 入库站，根据条码扫描生成入库工作档，工作状态 1 ==>> 2
     */
    @Async
    public void generateStoreWrkFile0() {
    public synchronized void generateStoreWrkFile0() {
        // 根据输送线plc遍历
        for (DevpSlave devp : slaveProperties.getDevp()) {
            // 遍历入库口
@@ -331,6 +331,7 @@
    /**
     * 拣料、并板、盘点再入库【第2阶段】
     */
    @Transactional
    public synchronized void stnToCrnStnPick1(){
        for (DevpSlave devp : slaveProperties.getDevp()) {
            // 遍历拣料入库口
@@ -455,6 +456,7 @@
                            }

                            String sourceLocNo = wrkMast.getSourceLocNo().trim();

                            // 更新工作档数据状态
                            wrkMast.setIoType(wrkMast.getIoType() - 50); // 入出库类型: 103->53,104->54,107->57
                            wrkMast.setWrkSts(2L); // 工作状态: 2.设备上走
@@ -470,14 +472,8 @@
                            if (wrkMastMapper.setSteEmpty(wrkMast.getWrkNo()) == 0) {
                                throw new CoolException(wrkMast.getWrkNo() + "更新工作档数据状态失败");
                            }

                            LocMast locMast = null;
                            // 修改源库位状态 O.空库位
//                            locMast = locMastService.selectById(sourceLocNo);
//                            locMast.setLocSts("O");
//                            locMast.setModiTime(new Date());
//                            if (!locMastService.updateById(locMast)) {
//                                throw new CoolException(wrkMast.getWrkNo() + "修改源库位状态 O.空库位");
//                            }
                            // 修改目标库位状态 Q.拣料/盘点/并板再入库
                            locMast = locMastService.selectById(wrkMast.getLocNo());
                            locMast.setLocSts("Q");
@@ -485,10 +481,21 @@
                            if (!locMastService.updateById(locMast)) {
                                throw new CoolException(wrkMast.getWrkNo() + "修改目标库位状态 Q.拣料/盘点/并板再入库");
                            }
                            // 库存明细转移
//                            if (!locDetlService.updateLocNo(wrkMast.getLocNo(), sourceLocNo)) {
//                                throw new CoolException(wrkMast.getWrkNo() + "任务库存明细转移失败！！！");
//                            }
                            // 源库位库存明细转移到目标库位
                            if (!locDetlService.updateLocNo(wrkMast.getLocNo(), sourceLocNo)) {
                                throw new CoolException(wrkMast.getLocNo() + "任务库存明细转移失败！！！");
                            }

                            // 修改源库位状态 O.空库位
                            LocMast sourceLocMast = locMastService.selectById(sourceLocNo);
                            if (sourceLocMast.getLocSts().equals("P")) {
                                sourceLocMast.setLocSts("O");
                                sourceLocMast.setModiTime(new Date());
                                if (!locMastService.updateById(sourceLocMast)) {
                                    throw new CoolException(wrkMast.getWrkNo() + "修改源库位状态 O.空库位");
                                }
                                locDetlService.delete(new EntityWrapper<LocDetl>().eq("loc_no", sourceLocNo));
                            }

                            // 条码设备处理
                            barcodeThread.setBarcode("");
@@ -541,19 +548,19 @@
    /**
     * 盘点货物抵达盘点目标站 wrkMast.sourceLoc P ===>> O
     */
    public void pickWrkCompleteStaNo() {
    public synchronized void pickWrkCompleteStaNo() {
        List<WrkMast> wrkMasts = wrkMastMapper.selectPick17(null, null);
        for (WrkMast wrkMast : wrkMasts) {
            // 修改源库位状态 O.空库位
            LocMast locMast = locMastService.selectById(wrkMast.getSourceLocNo());
            if (locMast.getLocSts().equals("P")) {
                locMast.setLocSts("O");
                locMast.setModiTime(new Date());
                if (!locMastService.updateById(locMast)) {
                    throw new CoolException(wrkMast.getWrkNo() + "修改源库位状态 O.空库位");
                }
                locDetlService.delete(new EntityWrapper<LocDetl>().eq("loc_no", wrkMast.getSourceLocNo()));
            }
//            // 修改源库位状态 O.空库位
//            LocMast locMast = locMastService.selectById(wrkMast.getSourceLocNo());
//            if (locMast.getLocSts().equals("P")) {
//                locMast.setLocSts("O");
//                locMast.setModiTime(new Date());
//                if (!locMastService.updateById(locMast)) {
//                    throw new CoolException(wrkMast.getWrkNo() + "修改源库位状态 O.空库位");
//                }
//                locDetlService.delete(new EntityWrapper<LocDetl>().eq("loc_no", wrkMast.getSourceLocNo()));
//            }
            // 修改工作档
            wrkMast.setIoPri(13D);
            wrkMast.setModiTime(new Date());
@@ -564,10 +571,72 @@
    }

    /**
     * 拣料/盘点转全板后，300站任务转100/200站去
     */
    public synchronized void transPickToFullChangeStn() {
        for (DevpSlave devp : slaveProperties.getDevp()) {
            // 遍历拣料出库口
            for (DevpSlave.Sta pickSta : devp.getPickOutSta()) {
                // 获取拣料出库站信息
                DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, devp.getId());
                StaProtocol staProtocol = devpThread.getStation().get(pickSta.getStaNo());
                if (staProtocol == null) {
                    continue;
                } else {
                    staProtocol = staProtocol.clone();
                }

                if (staProtocol.isAutoing()
                        && staProtocol.isLoading()
                        && staProtocol.isInEnable()
                        && staProtocol.getWorkNo() > 0
                        && staProtocol.getStaNo().equals(staProtocol.getSiteId().shortValue())
                        && staProtocol.isPakMk()){
                    WrkMast wrkMast = wrkMastMapper.selectById(staProtocol.getWorkNo());
                    if(Cools.isEmpty(wrkMast)){
                        log.error("拣料/盘点转全板,任务号工作档不存在===>>[任务号:{}]", staProtocol.getWorkNo());
                        continue;
                    }
                    if (wrkMast.getIoType() != 101) { continue; }

                    //拣料转全板默认出库站100站，当100站有物时，目标改200站
                    Integer staNo = 100;
                    StaProtocol staProtocol100 = devpThread.getStation().get(staNo);
                    if (staProtocol100 == null) {
                        continue;
                    } else {
                        staProtocol100 = staProtocol100.clone();
                    }
                    if (staProtocol100.isLoading()) {
                        staNo = 200;
                    }

                    // 更新站点信息 且 下发plc命令
                    staProtocol.setWorkNo(wrkMast.getWrkNo().shortValue());
                    staProtocol.setStaNo(staNo.shortValue());
                    devpThread.setPakMk(staProtocol.getSiteId(), false);
                    boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
                    if (!result) {
                        log.error("发布命令至输送线队列失败！！！ [plc编号：{}]", devp.getId());
                    } else {
                        wrkMast.setStaNo(staNo);
                        wrkMast.setModiTime(new Date());
                        if (wrkMastMapper.updateById(wrkMast) == 0) {
                            log.error("更新工作档的目标站失败！！！ [工作号:{}]", wrkMast.getWrkNo());
                        }
                    }

                }
            }


        }
    }

    /**
     * 堆垛机站出库到出库站
     */
    @Async
    public void crnStnToOutStn() {
    public synchronized void crnStnToOutStn() {
        for (CrnSlave crnSlave : slaveProperties.getCrn()) {
            // 遍历堆垛机出库站
            for (CrnSlave.CrnStn crnStn : crnSlave.getCrnOutStn()) {
@@ -612,6 +681,7 @@

                        // 更新工作档状态为 17.出库完成
                        wrkMast.setWrkSts(17L);
                        wrkMast.setSteNo(0);
                        wrkMast.setCrnEndTime(new Date());
                        if (wrkMastMapper.updateById(wrkMast) != 0) {
                            // 复位堆垛机
@@ -684,7 +754,7 @@
    /**
     * 入库  ===>>  堆垛机站到库位
     */
    public boolean crnStnToLoc(CrnSlave slave, CrnProtocol crnProtocol){
    public synchronized boolean crnStnToLoc(CrnSlave slave, CrnProtocol crnProtocol){
        for (CrnSlave.CrnStn crnStn : slave.getCrnInStn()) {
            boolean flag = false;
            // 获取堆垛机入库站信息
@@ -715,6 +785,18 @@
//                log.error("{}站点查询无待入库数据 工作号={}", crnStn.getStaNo(), staProtocol.getWorkNo());
                continue;
            }

            // 判断是否已存在小车绑定任务
            BasSte basSte = basSteService.findByCrnNo(wrkMast.getCrnNo());
            if(basSte == null) continue;
            WrkMast one1 = wrkMastService.selectOne(new EntityWrapper<WrkMast>()
                    .eq("ste_no",basSte.getSteNo())
                    .last(" and wrk_sts > 10"));
            if(one1 != null){
                log.error("{}入库任务无法作业，因出库任务已绑定小车!", wrkMast.getWrkNo());
                continue;
            }

            if (wrkMast.getWrkSts() < 3) {
                if (staProtocol.isAutoing() && staProtocol.isLoading() && staProtocol.getWorkNo() > 0 && staProtocol.isInEnable()
                        && staDetl.getCanining()!=null && staDetl.getCanining().equals("Y")) {
@@ -792,6 +874,7 @@
                        crnCommand.setCrnNo(slave.getId()); // 堆垛机编号
                        crnCommand.setTaskNo(wrkMast.getWrkNo().shortValue()); // 工作号
                        crnCommand.setAckFinish((short) 0);  // 任务完成确认位
                        crnCommand.setCommand((short) 0);
                        crnCommand.setTaskMode(CrnTaskModeType.LOC_MOVE); // 任务模式:  库位移转
                        crnCommand.setSourcePosX(crnStn.getRow().shortValue());     // 源库位排
                        crnCommand.setSourcePosY(crnStn.getBay().shortValue());     // 源库位列
@@ -846,6 +929,7 @@
                            crnCommand.setCrnNo(slave.getId()); // 堆垛机编号
                            crnCommand.setTaskNo(wrkMast.getWrkNo().shortValue()); // 工作号
                            crnCommand.setAckFinish((short) 0);  // 任务完成确认位
                            crnCommand.setCommand((short) 0);
                            crnCommand.setTaskMode(CrnTaskModeType.LOC_MOVE); // 任务模式:  库位移转
                            crnCommand.setSourcePosX(crnStn.getRow().shortValue());     // 源库位排
                            crnCommand.setSourcePosY(crnStn.getBay().shortValue());     // 源库位列
@@ -870,7 +954,7 @@
                    }
                // 没有小车
                } else {
                    if (wrkMast.getWrkSts() == 2L && wrkMast.getSteNo() == null) {
                    if (wrkMast.getWrkSts() == 2L && (wrkMast.getSteNo() == null || wrkMast.getSteNo() == 0)) {
                        // 寻找当前堆垛机对应的小车
                        SteThread steThread = queryIdleCar(wrkMast);
                        if (steThread != null) {
@@ -895,7 +979,7 @@
    /**
     * 出库  ===>>  库位到堆垛机站
     */
    public boolean locToCrnStn(CrnSlave slave, CrnProtocol crnProtocol){
    public synchronized boolean locToCrnStn(CrnSlave slave, CrnProtocol crnProtocol){
        for (CrnSlave.CrnStn crnStn : slave.getCrnOutStn()) {
            // 获取工作状态为11（生成出库ID）的出库工作档
            WrkMast wrkMast = wrkMastMapper.selectPakOutStep111215(slave.getId(), crnStn.getStaNo());
@@ -903,17 +987,28 @@
                continue;
            }

            // 判断是否已存在小车绑定任务
            BasSte basSte = basSteService.findByCrnNo(wrkMast.getCrnNo());
            if(basSte == null) continue;
            WrkMast one1 = wrkMastService.selectOne(new EntityWrapper<WrkMast>()
                    .eq("ste_no",basSte.getSteNo())
                    .last(" and wrk_sts < 10"));
            if(one1 != null){
                log.error("{}出库任务无法作业，因入库任务已绑定小车!", wrkMast.getWrkNo());
                continue;
            }

            //加强判断，确保因出库导致的移库整套任务全部结束后，才能执行下一笔出库任务。只有库位完成移库回去全部任务后，才认为当组出库任务完成
            WrkMast one = wrkMastMapper.selectLocMoveData(slave.getId());
            if(!Cools.isEmpty(one)){
                //存在移库任务，且在移出中，且移库源库位与待出库库位不在同一库位组，时跳出，确保移库/出库全套任务完成后，再执行下一笔
                if(one.getWrkSts() > 10 && (Utils.getGroupRow(wrkMast.getSourceLocNo()) != Utils.getGroupRow(one.getSourceLocNo())
                if(wrkMast.getWrkNo() == 11  && one.getWrkSts() > 10 && (Utils.getGroupRow(wrkMast.getSourceLocNo()) != Utils.getGroupRow(one.getSourceLocNo())
                        || Utils.getBay(wrkMast.getSourceLocNo()) != Utils.getBay(one.getSourceLocNo())
                        || Utils.getLev(wrkMast.getSourceLocNo()) != Utils.getLev(one.getSourceLocNo()))){
                    continue;
                }
                //存在移库任务，且在移回中，且移库目标库位与待出库库位不在同一库位组，时跳出，确保移库/出库全套任务完成后，再执行下一笔
                if(one.getWrkSts() < 11  && (Utils.getGroupRow(wrkMast.getSourceLocNo()) != Utils.getGroupRow(one.getLocNo())
                if(wrkMast.getWrkNo() == 11  && one.getWrkSts() < 11  && (Utils.getGroupRow(wrkMast.getSourceLocNo()) != Utils.getGroupRow(one.getLocNo())
                        || Utils.getBay(wrkMast.getSourceLocNo()) != Utils.getBay(one.getLocNo())
                        || Utils.getLev(wrkMast.getSourceLocNo()) != Utils.getLev(one.getLocNo()))){
                    continue;
@@ -924,7 +1019,7 @@
            boolean flag = false;
            if(!locMastService.isOutMost(wrkMast.getSourceLocNo())){
                WrkMast wrkMastMove = wrkMastMapper.selectLocMoveWorking(slave.getId());
                if(wrkMastMove != null){
                if(wrkMastMove != null && wrkMast.getWrkNo() == 11){
                    continue;
                }

@@ -1032,6 +1127,7 @@
                    crnCommand.setCrnNo(slave.getId()); // 堆垛机编号
                    crnCommand.setTaskNo(wrkMast.getWrkNo().shortValue()); // 工作号
                    crnCommand.setAckFinish((short) 0);  // 任务完成确认位
                    crnCommand.setCommand((short) 0);
                    crnCommand.setTaskMode(CrnTaskModeType.LOC_MOVE); // 任务模式:  库位移转
                    crnCommand.setSourcePosX(sourceSta.getRow1().shortValue());     // 源库位排
                    crnCommand.setSourcePosY(sourceSta.getBay1().shortValue());     // 源库位列
@@ -1066,6 +1162,12 @@
                            if (steProtocol == null) { continue; }
                            if (steProtocol.isIdle()) {

                                //小车只能绑定一笔作业中任务
                                WrkMast wrkMast1 = wrkMastMapper.selectSteNoData(steNo);
                                if(wrkMast1 != null){
                                    continue;
                                }

                                // 命令下发区 --------------------------------------------------------------------------
                                SteCommand steCommand = new SteCommand();
                                steCommand.setSteNo(steNo); // 穿梭车编号
@@ -1075,10 +1177,12 @@
                                steCommand.setRow(Utils.getGroupRow(steProtocol.getRow().intValue()).shortValue());
                                steCommand.setBay(steProtocol.getBay());
                                steCommand.setLev(steProtocol.getLev());
                                steCommand.setMemo("11==>14小车搬出库任务，任务号"+wrkMast.getWrkNo()+"");

                                if (!MessageQueue.offer(SlaveType.Ste, steNo, new Task(2, steCommand))) {
                                    log.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", steNo, JSON.toJSON(steCommand));
                                } else {
                                    log.info("穿梭车命令下发成功(11==>14小车搬出库任务)，穿梭车号={}，任务数据={}", steNo, JSON.toJSON(steCommand));
                                    // 修改工作档状态 11.生成出库ID => 14.小车搬出库
                                    Date now = new Date();
                                    wrkMast.setWrkSts(14L);
@@ -1102,6 +1206,7 @@
                            crnCommand.setCrnNo(slave.getId()); // 堆垛机编号
                            crnCommand.setTaskNo(wrkMast.getWrkNo().shortValue()); // 工作号
                            crnCommand.setAckFinish((short) 0);  // 任务完成确认位
                            crnCommand.setCommand((short) 0);
                            crnCommand.setTaskMode(CrnTaskModeType.LOC_MOVE); // 任务模式:  库位移转
                            crnCommand.setSourcePosX(Utils.getGroupRow(sourceSta.getRow1()).shortValue());     // 源库位排
                            crnCommand.setSourcePosY(sourceSta.getBay1().shortValue());     // 源库位列
@@ -1168,12 +1273,29 @@
    /**
     * 库位移转 NEW
     */
    public void locToLoc1(CrnSlave slave, CrnProtocol crnProtocol){
    public synchronized void locToLoc1(CrnSlave slave, CrnProtocol crnProtocol){
        // 获取工作档信息
        WrkMast wrkMast = wrkMastMapper.selectLocMove(slave.getId());
        if (null == wrkMast) {
            return;
        }
        // 过滤
        if (null != wrkMastMapper.selectPakin(slave.getId(), null)) {
            log.error("{}出库任务无法作业，因存在入库中任务!", wrkMast.getWrkNo());
            return;
        }

        // 判断是否已存在小车绑定任务
        BasSte basSte = basSteService.findByCrnNo(wrkMast.getCrnNo());
        if(basSte == null) return;
        WrkMast one = wrkMastService.selectOne(new EntityWrapper<WrkMast>()
                .eq("ste_no",basSte.getSteNo())
                .last(" and io_type != 11 and wrk_sts < 10"));
        if(one != null){
            log.error("{}移库任务无法作业，因入库任务已绑定小车!", wrkMast.getWrkNo());
            return;
        }

        // 获取源库位信息
        LocMast sourceLoc = locMastService.selectById(wrkMast.getSourceLocNo());
        if (null == sourceLoc) {
@@ -1219,6 +1341,7 @@
                crnCommand.setCrnNo(slave.getId()); // 堆垛机编号
                crnCommand.setTaskNo(wrkMast.getWrkNo().shortValue()); // 工作号
                crnCommand.setAckFinish((short) 0);  // 任务完成确认位
                crnCommand.setCommand((short) 0);
                crnCommand.setTaskMode(CrnTaskModeType.LOC_MOVE); // 任务模式:  库位移转
                crnCommand.setSourcePosX(sourceLoc.getRow1().shortValue());     // 源库位排
                crnCommand.setSourcePosY(sourceLoc.getBay1().shortValue());     // 源库位列
@@ -1253,6 +1376,12 @@
                    SteProtocol steProtocol = steThread.getSteProtocol();
                    if (steProtocol == null) { return; }
                    if (steProtocol.isIdle()) {

                        //小车只能绑定一笔作业中任务
                        WrkMast wrkMast1 = wrkMastMapper.selectSteNoData(steNo);
                        if(wrkMast1 != null){
                            return;
                        }

                        // 命令下发区 --------------------------------------------------------------------------
                        SteCommand steCommand = new SteCommand();
@@ -1290,6 +1419,7 @@
                    crnCommand.setCrnNo(slave.getId()); // 堆垛机编号
                    crnCommand.setTaskNo(wrkMast.getWrkNo().shortValue()); // 工作号
                    crnCommand.setAckFinish((short) 0);  // 任务完成确认位
                    crnCommand.setCommand((short) 0);
                    crnCommand.setTaskMode(CrnTaskModeType.LOC_MOVE); // 任务模式:  库位移转
                    crnCommand.setSourcePosX(Utils.getGroupRow(sourceLoc.getRow1()).shortValue());     // 源库位排
                    crnCommand.setSourcePosY(sourceLoc.getBay1().shortValue());     // 源库位列
@@ -1339,7 +1469,7 @@
    /**
     * 库位移转，回原库位
     */
    public void locToLoc17(CrnSlave slave, CrnProtocol crnProtocol){
    public synchronized void locToLoc17(CrnSlave slave, CrnProtocol crnProtocol){
        // 获取工作档信息
        WrkMast wrkMast = wrkMastMapper.selectLocMove17(slave.getId());
        if (null == wrkMast) {
@@ -1349,12 +1479,19 @@
        if (wrkMast.getWrkSts() == 17) {
            //查找库位
            boolean flag = false;
            String[] deeplocs  = Utils.getDeepLocs(wrkMast.getSourceLocNo());
//            append
            Integer row = Utils.getGroupRow(wrkMast.getSourceLocNo());
            Integer bay = Utils.getBay(wrkMast.getSourceLocNo());
            Integer lev = Utils.getLev(wrkMast.getSourceLocNo());

            String locNo = Utils.append(row, bay, lev);
            String[] deeplocs  = Utils.getDeepLocs(locNo);
            if(!Cools.isEmpty(deeplocs)){
                for(String deepLocNo : deeplocs) {
                    LocMast deepLoc = locMastService.selectById(deepLocNo);
//                WrkMast waitWrkMast = wrkMastMapper.selectByLocNo(deepLocNo);
                    if(deepLoc != null && !deepLoc.getLocSts().equals("F") && deepLoc.getLocSts().equals("D") && deepLoc.getLocSts().equals("O")){
                    if(deepLoc != null && !deepLoc.getLocSts().equals("F") && !deepLoc.getLocSts().equals("D") && !deepLoc.getLocSts().equals("O")){
                        log.error("移库再回库时，深库位组深库位状态为作业中 ===>> deepLoc={},loc_sts={}", deepLoc.getLocNo(), deepLoc.getLocSts());
                        flag = true;
                        break;
                    }
@@ -1364,10 +1501,10 @@
                        wrkMast.setIoPri((double)9999);
                        wrkMast.setWrkSts(2L);
                        wrkMast.setLocNo(deepLocNo);
                        wrkMast.setSteNo(null);
                        wrkMast.setSteNo(0);
                        wrkMast.setModiTime(new Date());
                        if (wrkMastMapper.updateById(wrkMast) == 0) {
                            log.error("修改工作档状态 11.生成出库ID => 12.吊车出库中 失败！！，工作号={}", wrkMast.getWrkNo());
                            log.error("修改工作档状态 17.移库完成 => 2.移库再入库中 失败！！，工作号={}", wrkMast.getWrkNo());
                        }

                        if(deepLoc.getLocSts().equals("O")){
@@ -1379,7 +1516,7 @@
                            }
                        }
                        LocMast sourceLoc = locMastService.selectById(wrkMast.getSourceLocNo());
                        if(sourceLoc.getLocSts().equals("F")){
                        if(sourceLoc.getLocSts().equals("F") || sourceLoc.getLocSts().equals("D")){
                            sourceLoc.setLocSts("R"); // R.出库预约
                            sourceLoc.setModiTime(new Date());
                            if (!locMastService.updateById(sourceLoc)) {
@@ -1442,10 +1579,23 @@
                // 有小车
                if (steNo != null) {
                    // 小车行走到堆垛机待搬移点
                    if (wrkMast.getWrkSts() == 2L && wrkMast.getSteNo() == null) {
                    if (wrkMast.getWrkSts() == 2L && (wrkMast.getSteNo() == null || wrkMast.getSteNo() == 0)) {
                        // 没有其他任务
                        if (null == wrkMastMapper.selectPakin(slave.getId(), steNo)) {
                            this.letCarBeWaiting(wrkMast, steNo, wrkMast.getLocNo());
                            SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, steNo);
                            SteProtocol steProtocol = steThread.getSteProtocol();
                            if (steProtocol == null) { return; }
                            if(steProtocol.getLoca()==3 || steProtocol.getLoca()==4){
                                //小车已经在待机位时，无需下发到待机位任务，直接更新状态微3，同时绑定小车
                                wrkMast.setWrkSts(3L);
                                wrkMast.setSteNo(steNo);
                                wrkMast.setModiTime(new Date());
                                if (wrkMastMapper.updateById(wrkMast) == 0) {
                                    log.error("修改工作档状态 绑定穿梭车 失败！！，工作号={}", wrkMast.getWrkNo());
                                }
                            } else {
                                this.letCarBeWaiting(wrkMast, steNo, wrkMast.getLocNo());
                            }
                        }
                    }
                    // 堆垛机将货放至小车上 3.小车待搬（小车不用搬运，已经在当前组库位） / 6.小车待入  ===>> 7.吊车入库中
@@ -1465,6 +1615,7 @@
                            crnCommand.setCrnNo(slave.getId()); // 堆垛机编号
                            crnCommand.setTaskNo(wrkMast.getWrkNo().shortValue()); // 工作号
                            crnCommand.setAckFinish((short) 0);  // 任务完成确认位
                            crnCommand.setCommand((short) 0);
                            crnCommand.setTaskMode(CrnTaskModeType.LOC_MOVE); // 任务模式:  库位移转
                            crnCommand.setSourcePosX(sourceLoc.getRow1().shortValue());     // 源库位排
                            crnCommand.setSourcePosY(sourceLoc.getBay1().shortValue());     // 源库位列
@@ -1489,7 +1640,7 @@
                    }
                    // 没有小车
                } else {
                    if (wrkMast.getWrkSts() == 2L && wrkMast.getSteNo() == null) {
                    if (wrkMast.getWrkSts() == 2L && (wrkMast.getSteNo() == null || wrkMast.getSteNo() == 0)) {
                        // 寻找当前堆垛机对应的小车
                        SteThread steThread = queryIdleCar(wrkMast);
                        if (steThread != null) {
@@ -1517,7 +1668,7 @@
    /**
     * 库位移转
     */
    public void locToLoc(CrnSlave slave, CrnProtocol crnProtocol){
    public synchronized void locToLoc(CrnSlave slave, CrnProtocol crnProtocol){
        // 获取工作档信息
        WrkMast wrkMast = wrkMastMapper.selectLocMove(slave.getId());
        if (null == wrkMast) {
@@ -1570,6 +1721,7 @@
                crnCommand.setCrnNo(slave.getId()); // 堆垛机编号
                crnCommand.setTaskNo(wrkMast.getWrkNo().shortValue()); // 工作号
                crnCommand.setAckFinish((short) 0);  // 任务完成确认位
                crnCommand.setCommand((short) 0);
                crnCommand.setTaskMode(CrnTaskModeType.LOC_MOVE); // 任务模式:  库位移转
                crnCommand.setSourcePosX(sourceLoc.getRow1().shortValue());     // 源库位排
                crnCommand.setSourcePosY(sourceLoc.getBay1().shortValue());     // 源库位列
@@ -1620,6 +1772,7 @@
                            crnCommand.setCrnNo(slave.getId()); // 堆垛机编号
                            crnCommand.setTaskNo(wrkMast.getWrkNo().shortValue()); // 工作号
                            crnCommand.setAckFinish((short) 0);  // 任务完成确认位
                            crnCommand.setCommand((short) 0);
                            crnCommand.setTaskMode(CrnTaskModeType.LOC_MOVE); // 任务模式:  库位移转
                            crnCommand.setSourcePosX(Utils.getGroupRow(sourceLoc.getRow1()).shortValue());     // 源库位排
                            crnCommand.setSourcePosY(sourceLoc.getBay1().shortValue());     // 源库位列
@@ -1676,6 +1829,12 @@
                    if (steProtocol == null) { return; }
                    if (steProtocol.isIdle()) {

                        //小车只能绑定一笔作业中任务
                        WrkMast wrkMast1 = wrkMastMapper.selectSteNoData(steNo);
                        if(wrkMast1 != null){
                            return;
                        }

                        // 命令下发区 --------------------------------------------------------------------------
                        SteCommand steCommand = new SteCommand();
                        steCommand.setSteNo(steNo); // 穿梭车编号
@@ -1714,6 +1873,7 @@
                        crnCommand.setCrnNo(slave.getId()); // 堆垛机编号
                        crnCommand.setTaskNo(wrkMast.getWrkNo().shortValue()); // 工作号
                        crnCommand.setAckFinish((short) 0);  // 任务完成确认位
                        crnCommand.setCommand((short) 0);
                        crnCommand.setTaskMode(CrnTaskModeType.LOC_MOVE); // 任务模式:  库位移转
                        crnCommand.setSourcePosX(Utils.getGroupRow(sourceLoc.getRow1()).shortValue());     // 源库位排
                        crnCommand.setSourcePosY(sourceLoc.getBay1().shortValue());     // 源库位列
@@ -1760,6 +1920,7 @@
                                crnCommand.setCrnNo(slave.getId()); // 堆垛机编号
                                crnCommand.setTaskNo(wrkMast.getWrkNo().shortValue()); // 工作号
                                crnCommand.setAckFinish((short) 0);  // 任务完成确认位
                                crnCommand.setCommand((short) 0);
                                crnCommand.setTaskMode(CrnTaskModeType.LOC_MOVE); // 任务模式:  库位移转
                                crnCommand.setSourcePosX(Utils.getGroupRow(sourceLoc.getRow1()).shortValue());     // 源库位排
                                crnCommand.setSourcePosY(sourceLoc.getBay1().shortValue());     // 源库位列
@@ -1810,7 +1971,7 @@
    /**
     * 当前库位组是否存在空闲小车
     */
    public Integer hasCar(String locNo) {
    public synchronized Integer hasCar(String locNo) {
        for (SteSlave ste : slaveProperties.getSte()) {
            // 获取堆垛机信息
            SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, ste.getId());
@@ -1826,7 +1987,7 @@
    /**
     * 当前库位组是否存在空闲小车
     */
    public Integer hasCarOfIdle(String locNo) {
    public synchronized Integer hasCarOfIdle(String locNo) {
        for (SteSlave ste : slaveProperties.getSte()) {
            // 获取堆垛机信息
            SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, ste.getId());
@@ -1844,7 +2005,7 @@
    /**
     * 查找当前库位最适合的穿梭车来作业
     */
    public SteThread queryIdleCar(WrkMast wrkMast) {
    public synchronized SteThread queryIdleCar(WrkMast wrkMast) {
        Integer crnNo = wrkMast.getCrnNo();
        BasSte basSte = basSteService.findByCrnNo(crnNo);
        // 获取穿梭车信息
@@ -1862,12 +2023,18 @@
     * 让小车从 远点 ====>> 待机
     *  等待堆垛机搬运
     */
    public void letCarBeWaiting(WrkMast wrkMast, Integer steNo, String locNo) {
    public synchronized void letCarBeWaiting(WrkMast wrkMast, Integer steNo, String locNo) {
        // 获取穿梭车信息
        SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, steNo);
        SteProtocol steProtocol = steThread.getSteProtocol();
        if (steProtocol == null) { return; }
        if (steProtocol.isIdle()) {

            //小车只能绑定一笔作业中任务
            WrkMast wrkMast1 = wrkMastMapper.selectSteNoData(steNo);
            if(wrkMast1 != null){
                return;
            }

            // 命令下发区 --------------------------------------------------------------------------
            SteCommand steCommand = new SteCommand();
@@ -1882,6 +2049,7 @@
            if (!MessageQueue.offer(SlaveType.Ste, steNo, new Task(2, steCommand))) {
                log.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", steNo, JSON.toJSON(steCommand));
            } else {
                log.error("穿梭车命令下发成功让小车从 远点 ====>> 待机位,绑定穿梭车,IoType={}, 穿梭车号={}，任务数据={}", wrkMast.getIoType(), steNo, JSON.toJSON(steCommand));
                // 修改工作档状态 绑定穿梭车
                wrkMast.setSteNo(steNo);
                wrkMast.setModiTime(new Date());
@@ -1892,7 +2060,7 @@
        }
    }

    public void letCarBeWaiting(WrkCharge wrkCharge, Integer steNo) {
    public synchronized void letCarBeWaiting(WrkCharge wrkCharge, Integer steNo) {
        // 获取穿梭车信息
        SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, steNo);
        SteProtocol steProtocol = steThread.getSteProtocol();
@@ -1900,6 +2068,12 @@

        if (!basSteService.updatePakMk(steNo, "Y")) {
            log.error("修改穿梭车作业状态 失败！！，穿梭车={}", steNo);
            return;
        }

        //小车只能绑定一笔作业中任务
        WrkMast wrkMast1 = wrkMastMapper.selectSteNoData(steNo);
        if(wrkMast1 != null){
            return;
        }

@@ -1929,12 +2103,18 @@
     * 让小车从 远点 ====>> 移动到近点
     *  等待堆垛机搬运
     */
    public void letCarBeReady(WrkMast wrkMast, Integer steNo, String locNo) {
    public synchronized void letCarBeReady(WrkMast wrkMast, Integer steNo, String locNo) {
        // 获取穿梭车信息
        SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, steNo);
        SteProtocol steProtocol = steThread.getSteProtocol();
        if (steProtocol == null) { return; }
        if (steProtocol.isIdle()) {

            //小车只能绑定一笔作业中任务
            WrkMast wrkMast1 = wrkMastMapper.selectSteNoData(steNo);
            if(wrkMast1 != null){
                return;
            }

            // 命令下发区 --------------------------------------------------------------------------
            SteCommand steCommand = new SteCommand();
@@ -1945,10 +2125,12 @@
            steCommand.setRow(Utils.getGroupRow(steProtocol.getRow().intValue()).shortValue());
            steCommand.setBay(steProtocol.getBay());
            steCommand.setLev(steProtocol.getLev());
            steCommand.setMemo("绑定小车号，让小车从 远点 ====>> 移动到近点");

            if (!MessageQueue.offer(SlaveType.Ste, steNo, new Task(2, steCommand))) {
                log.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", steNo, JSON.toJSON(steCommand));
            } else {
                log.info("穿梭车命令下发成功(让小车从远点==>>移动到近点)，IoType={}, 穿梭车号={}，任务数据={}", wrkMast.getIoType(), steNo, JSON.toJSON(steCommand));
                // 修改工作档状态 绑定穿梭车
                wrkMast.setSteNo(steNo);
                wrkMast.setModiTime(new Date());
@@ -1963,12 +2145,18 @@
     * 让小车从 远点 ====>> 移动到近点
     *  等待堆垛机搬运
     */
    public void letCarBeReady(WrkCharge wrkCharge, Integer steNo) {
    public synchronized void letCarBeReady(WrkCharge wrkCharge, Integer steNo) {
        // 获取穿梭车信息
        SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, steNo);
        SteProtocol steProtocol = steThread.getSteProtocol();
        if (steProtocol == null) { return; }
        if (steProtocol.isIdle()) {

            //小车只能绑定一笔作业中任务
            WrkMast wrkMast1 = wrkMastMapper.selectSteNoData(steNo);
            if(wrkMast1 != null){
                return;
            }

            // 命令下发区 --------------------------------------------------------------------------
            SteCommand steCommand = new SteCommand();
@@ -1996,12 +2184,12 @@
    /**
     * 入出库  ===>>  堆垛机搬入小车
     */
    public void carMoveIn(WrkMast wrkMast, Integer steNo, CrnProtocol crnProtocol) {
    public synchronized void carMoveIn(WrkMast wrkMast, Integer steNo, CrnProtocol crnProtocol) {
        // 获取堆垛机信息
        SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, steNo);
        SteProtocol steProtocol = steThread.getSteProtocol();
        if (steProtocol == null) { return; }
        if (steProtocol.isIdle()) {
        if (steProtocol.isIdle() && steProtocol.getLoad() == 0) {
            // 堆垛机空闲
            if (crnProtocol.getStatusType().equals(CrnStatusType.IDLE) || crnProtocol.getTaskNo() == 0) {
                LocMast locMast;
@@ -2013,6 +2201,7 @@
                    crnCommand.setCrnNo(crnProtocol.getCrnNo()); // 堆垛机编号
                    crnCommand.setTaskNo(wrkMast.getWrkNo().shortValue()); // 工作号
                    crnCommand.setAckFinish((short) 0);  // 任务完成确认位
                    crnCommand.setCommand((short) 0);
                    crnCommand.setTaskMode(CrnTaskModeType.STE_MOVE); // 任务模式:  库位移转
                    crnCommand.setSourcePosX(Utils.getGroupRow(steProtocol.getRow().intValue()).shortValue());     // 源库位排
                    crnCommand.setSourcePosY(steProtocol.getBay());     // 源库位列
@@ -2042,6 +2231,7 @@
                    crnCommand.setCrnNo(crnProtocol.getCrnNo()); // 堆垛机编号
                    crnCommand.setTaskNo(wrkMast.getWrkNo().shortValue()); // 工作号
                    crnCommand.setAckFinish((short) 0);  // 任务完成确认位
                    crnCommand.setCommand((short) 0);
                    crnCommand.setTaskMode(CrnTaskModeType.STE_MOVE); // 任务模式:  库位移转
                    crnCommand.setSourcePosX(Utils.getGroupRow(steProtocol.getRow().intValue()).shortValue());     // 源库位排
                    crnCommand.setSourcePosY(steProtocol.getBay());     // 源库位列
@@ -2072,13 +2262,13 @@
    /**
     * 入库  ===>>  堆垛机搬出小车
     */
    public void carMoveOut(WrkMast wrkMast, Integer steNo, CrnProtocol crnProtocol) {
    public synchronized void carMoveOut(WrkMast wrkMast, Integer steNo, CrnProtocol crnProtocol) {
        // 获取穿梭车信息
        SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, steNo);
        SteProtocol steProtocol = steThread.getSteProtocol();
        if (steProtocol == null) { return; }
        // 穿梭车空闲
        if (steProtocol.isIdle()) {
        if (steProtocol.isIdle() && steProtocol.getLoad() == 0) {
            // 堆垛机空闲
            if (crnProtocol.getStatusType().equals(CrnStatusType.IDLE) || crnProtocol.getTaskNo() == 0) {

@@ -2094,6 +2284,7 @@
                crnCommand.setCrnNo(crnProtocol.getCrnNo()); // 堆垛机编号
                crnCommand.setTaskNo(wrkMast.getWrkNo().shortValue()); // 工作号
                crnCommand.setAckFinish((short) 0);  // 任务完成确认位
                crnCommand.setCommand((short) 0);
                crnCommand.setTaskMode(CrnTaskModeType.STE_MOVE); // 任务模式:  库位移转
                crnCommand.setSourcePosX(Utils.getGroupRow(steProtocol.getRow().intValue()).shortValue());     // 源库位排
                crnCommand.setSourcePosY(steProtocol.getBay());     // 源库位列
@@ -2123,9 +2314,8 @@
    /**
     * 执行对工作档的完成操作
     */
    @Async
    @Transactional
    public void storeFinished() {
    public synchronized void storeFinished() {
        for (CrnSlave crn : slaveProperties.getCrn()) {
            // 获取堆垛机信息
            CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, crn.getId());
@@ -2301,9 +2491,11 @@
                        steCommand.setSteNo(steNo); // 穿梭车编号
                        steCommand.setTaskNo(wrkMast.getWrkNo()); // 工作号
                        steCommand.setTaskMode(SteTaskModeType.findOutByLoc(wrkMast.getSourceLocNo())); // 任务模式:  搬出库
                        steCommand.setMemo("出库 ===>> 迁入小车 完成");
                        if (!MessageQueue.offer(SlaveType.Ste, steNo, new Task(2, steCommand))) {
                            log.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", steNo, JSON.toJSON(steCommand));
                        } else {
                            log.info("穿梭车命令下发成功，穿梭车号={}，任务数据={}", steNo, JSON.toJSON(steCommand));
                            // 13.迁入小车 ==> 14.小车搬出库
                            wrkMast.setWrkSts(14L);
                            Date now = new Date();
@@ -2411,8 +2603,9 @@
//                        }
                        if (locMastService.isOutMost(wrkMast.getLocNo())) {
                            wrkMast.setWrkSts(17L);
                            wrkMast.setSteNo(0);
                            // 默认目标库位是空板
                            String locSts = "D";
                            String locSts = "";
                            // 库位移转判断是否为空板移转
                            if (wrkMast.getEmptyMk().equals("N")) {
                                locSts = "F";
@@ -2421,7 +2614,14 @@
                                    log.error("库位移转 ===>> 转移库存明细数据失败；[源库位={}],[目标库位={}]", wrkMast.getSourceLocNo(), wrkMast.getLocNo());
                                    continue;
                                }
                            } else {
                                locSts = "D";
                            }
                            if(Cools.isEmpty(locSts)){
                                log.error("库位移转 ===>> 库存状态为空；[源库位={}],[目标库位={}]", wrkMast.getSourceLocNo(), wrkMast.getLocNo());
                                continue;
                            }

                            // 修改源库位状态 ==> O
                            LocMast sourceLoc = locMastService.selectById(wrkMast.getSourceLocNo());
                            if (null != sourceLoc) {
@@ -2571,8 +2771,12 @@
            SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, ste.getId());
            SteProtocol steProtocol = steThread.getSteProtocol();
            if (steProtocol == null) { continue; }
            if (steProtocol.getWaiting() && steProtocol.getTaskNo() != 0) {
                log.info("ste[id={}] 执行工作档完成，任务号={}", steProtocol.getSteNo(), steProtocol.getTaskNo());
            if (steProtocol.getWaiting() && steProtocol.getTaskNo() == 0){
                log.info("ste[id={}] 收到等待WCS确认信号，但是任务号(地址V824)为0", steProtocol.getSteNo());
            }

            if (steProtocol.getWaiting() && steProtocol.getTaskNo() != 0 && steProtocol.getStatus() == 10) {
                log.info("ste[id={}] 执行工作档完成，任务号={}, 穿梭车状态={}", steProtocol.getSteNo(), steProtocol.getTaskNo(), steProtocol.getStatus());
                if (steProtocol.getTaskNo() == 9999) {
                    steThread.setResetFlag(true);
                } else {
@@ -2691,7 +2895,7 @@
    /**
     * 异常信息记录
     */
    public void recErr() {
    public synchronized void recErr() {
        try {
            this.recCrnErr();
            this.recSteErr();
@@ -2703,7 +2907,7 @@
    /**
     * 堆垛机异常信息记录
     */
    private void recCrnErr(){
    private synchronized void recCrnErr(){
        Date now = new Date();
        for (CrnSlave crn : slaveProperties.getCrn()) {
            // 获取堆垛机信息
@@ -2934,8 +3138,7 @@
    /**
     * 空栈板初始化入库,叉车入库站放货
     */
    @Async
    public void storeEmptyPlt(){
    public synchronized void storeEmptyPlt(){
        for (DevpSlave devp : slaveProperties.getDevp()) {
            // 遍历空板入库口
            for (DevpSlave.Sta emptyInSta : devp.getEmptyInSta()) {
@@ -3025,8 +3228,7 @@
    /**
     * 出库  ===>> 工作档信息写入led显示器
     */
    @Async
    public void ledExecute() {
    public synchronized void ledExecute() {
        for (LedSlave led : slaveProperties.getLed()) {
            // 获取输送线plc线程
            DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, led.getDevpPlcId());
@@ -3078,10 +3280,13 @@
                    List<WrkDetl> wrkDetls = wrkDetlService.findByWorkNo(wrkMast.getWrkNo());
                    wrkDetls.forEach(wrkDetl -> {
                        if (wrkMast.getIoType() == 101) {
                            ledCommand.getMatDtos().add(new MatDto(wrkDetl.getMatnr(), wrkDetl.getMaktx(), wrkDetl.getBatch(), wrkDetl.getAnfme()));
                            ledCommand.getMatDtos().add(new MatDto(wrkDetl.getMatnr(), wrkDetl.getMaktx(), wrkDetl.getBatch(), wrkDetl.getSpecs(), wrkDetl.getAnfme()));
                        }
                        if (wrkMast.getIoType() == 103 && (null == wrkDetl.getInspect() || 0 == wrkDetl.getInspect())) {
                            ledCommand.getMatDtos().add(new MatDto(wrkDetl.getMatnr(), wrkDetl.getMaktx(), wrkDetl.getBatch(), wrkDetl.getAnfme()));
                            ledCommand.getMatDtos().add(new MatDto(wrkDetl.getMatnr(), wrkDetl.getMaktx(), wrkDetl.getBatch(), wrkDetl.getSpecs(), wrkDetl.getAnfme()));
                        }
                        if (wrkMast.getIoType() == 107) {
                            ledCommand.getMatDtos().add(new MatDto(wrkDetl.getMatnr(), wrkDetl.getMaktx(), wrkDetl.getBatch(), wrkDetl.getSpecs(), wrkDetl.getAnfme()));
                        }
                    });
                }
@@ -3126,8 +3331,7 @@
    /**
     * 其他  ===>> LED显示器复位，显示默认信息
     */
    @Async
    public void ledReset() {
    public synchronized void ledReset() {
        for (LedSlave led : slaveProperties.getLed()) {
            // 获取输送线plc线程
            DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, led.getDevpPlcId());
@@ -3222,6 +3426,7 @@
                        crnCommand.setCrnNo(wrkCharge.getCrnNo()); // 堆垛机编号
                        crnCommand.setTaskNo(wrkCharge.getWrkNo().shortValue()); // 工作号
                        crnCommand.setAckFinish((short) 0);  // 任务完成确认位
                        crnCommand.setCommand((short) 0);
                        crnCommand.setTaskMode(CrnTaskModeType.STE_MOVE); // 任务模式:  库位移转
                        crnCommand.setSourcePosX(Utils.getGroupRow(steProtocol.getRow().intValue()).shortValue());     // 源库位排
                        crnCommand.setSourcePosY(steProtocol.getBay());     // 源库位列
@@ -3430,6 +3635,7 @@
                crnCommand.setCrnNo(crnProtocol.getCrnNo()); // 堆垛机编号
                crnCommand.setTaskNo(wrkCharge.getWrkNo().shortValue()); // 工作号
                crnCommand.setAckFinish((short) 0);  // 任务完成确认位
                crnCommand.setCommand((short) 0);
                crnCommand.setTaskMode(CrnTaskModeType.STE_MOVE); // 任务模式:  库位移转
                crnCommand.setSourcePosX(Utils.getGroupRow(steProtocol.getRow().intValue()).shortValue());     // 源库位排
                crnCommand.setSourcePosY(steProtocol.getBay());     // 源库位列
@@ -3496,7 +3702,7 @@
    /**
     * 因深库位阻塞，对浅库位进行移转
     */
    private void moveLocForDeepLoc(CrnSlave crn, LocMast shallowLoc){
    private synchronized void moveLocForDeepLoc(CrnSlave crn, LocMast shallowLoc){
        try {
            String rows = "";
            switch (crn.getId()){
@@ -3510,10 +3716,19 @@
                    rows = "18,19";
                    break;
            }
            LocMast loc = locMastService.selectOne(new EntityWrapper<LocMast>().eq("crn_no",crn.getId())
            LocMast loc = null;
            List<LocMast> locs = locMastService.selectList(new EntityWrapper<LocMast>().eq("crn_no",crn.getId())
                                                .eq("loc_type1",shallowLoc.getLocType1())
                                                .eq("loc_sts","O")
                                                .last(" and row1 in (" + rows + ") order by bay1,lev1"));
            for (LocMast one : locs){
                if(Utils.getGroupRow(one.getLocNo()) != Utils.getGroupRow(shallowLoc.getLocNo())
                    || Utils.getBay(one.getLocNo()) != Utils.getBay(shallowLoc.getLocNo())
                    || Utils.getLev(one.getLocNo()) != Utils.getLev(shallowLoc.getLocNo())){
                    loc = one;
                    break;
                }
            }

            if (null == loc) {
                log.error("深库位出库 --- 浅库位阻塞异常！ 待移转浅库位：" + shallowLoc.getLocNo());