#

tqs

2022-10-31 bfbe2204cfb0eea3f000b145f5e3f19eca89aa68

#

 src/main/java/com/zy/asrs/mapper/WrkMastMapper.java

@@ -83,4 +83,17 @@

    WrkMast selectPakout(@Param("crnNo")Integer crnNo, @Param("steNo")Integer steNo);

    /**
     * 查询工作档是是否存在未完成的移库任务，状态17表示移库已经完成，等待回原库位
     * @param crnNo
     * @return
     */
    WrkMast selectLocMoveWorking(@Param("crnNo")Integer crnNo);

    /**
     * 查找工作状态为17的移库完成任务，待处理回到原库位，并顺序往里移动
     * @param crnNo
     * @return
     */
    WrkMast selectLocMove17(@Param("crnNo")Integer crnNo);
}

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

@@ -11,6 +11,7 @@
import com.zy.asrs.mapper.WrkMastMapper;
import com.zy.asrs.service.*;
import com.zy.asrs.utils.Utils;
import com.zy.asrs.utils.VersionUtils;
import com.zy.common.model.LocTypeDto;
import com.zy.common.model.MatDto;
import com.zy.common.model.SearchLocParam;
@@ -645,7 +646,9 @@
                    }
                }
                // 库位移转
                this.locToLoc(crn, crnProtocol);
                this.locToLoc1(crn, crnProtocol);
                // 库位移转，回原库位
                this.locToLoc17(crn, crnProtocol);
                // 演示任务
                this.steMoveDemo(crn, crnProtocol);
            }
@@ -865,6 +868,59 @@
            if (wrkMast == null) {
                continue;
            }

            //出库库位不是最外层库位，判断浅库位组是否都为空，或存在库位移转任务
            boolean flag = false;
            if(!locMastService.isOutMost(wrkMast.getSourceLocNo())){
                WrkMast wrkMastMove = wrkMastMapper.selectLocMoveWorking(slave.getId());
                if(wrkMastMove != null){
                    continue;
                }

                String[] shallowlocs  = Utils.getShallowLocs(wrkMast.getSourceLocNo());
                if(!Cools.isEmpty(shallowlocs)){
                    for(String shallowLocNo : shallowlocs){
                        LocMast shallowLoc = locMastService.selectById(shallowLocNo);
                        WrkMast waitWrkMast = wrkMastMapper.selectByLocNo(shallowLocNo);
                        if (shallowLoc.getLocSts().equals("P") || shallowLoc.getLocSts().equals("R")) {
                            if (null == waitWrkMast) {
                                log.error("{}库位异常，未检索到相应工作档！", shallowLocNo);
                            } else {
                                //iotype=11，wrksts=17，说明货物已经移库到暂存库位，等待回原库位,此时允许继续出库
                                if (waitWrkMast.getIoType()!=11 || waitWrkMast.getWrkSts()!=17) {
                                    waitWrkMast.setIoPri((double) 9999);
                                    waitWrkMast.setModiTime(new Date());
                                    if (wrkMastMapper.updateById(waitWrkMast) == 0) {
                                        log.error("调整工作档优先级失败！工作号={}", waitWrkMast.getWrkNo());
                                    }
                                    flag = true;
                                    break;
                                }
                            }
                        } else if (shallowLoc.getLocSts().equals("F") || shallowLoc.getLocSts().equals("D")) {
                            if (null == waitWrkMast) {
                                // 生成一笔移库任务工作档、改变浅库位的源库/目标库 库位状态
                                moveLocForDeepLoc(slave, shallowLoc);
                                flag = true;
                                break;
                            } else {
                                log.error("库位出库到堆垛机站 ===>> 库位状态在库，但是浅库位已存在工作档任务！出库库位={},浅库位号={}", shallowLoc.getLocNo());
                                flag = true;
                                break;
                            }
                        } else if (shallowLoc.getLocSts().equals("Q") || shallowLoc.getLocSts().equals("S")){
                            log.error("库位出库到堆垛机站 ===>> 浅库位库位状态为入库预约！出库库位={},浅库位号={}", shallowLoc.getLocNo());
                            flag = true;
                            break;
                        }

                    }
                }
            }
            if(flag){
                continue;
            }

            // 工作档状态判断
            if (wrkMast.getIoType() < 100 || wrkMast.getSourceStaNo() == null){
                log.error("查询工作档数据不符合条件--入出类型/站点, 工作号={}，源库位={}，入出类型={}", wrkMast.getWrkNo(), wrkMast.getSourceLocNo(), wrkMast.getIoType());
@@ -1216,6 +1272,169 @@
                // 堆垛机搬运小车
                if (wrkMast.getWrkSts() == 12L) {
                    this.carMoveIn(wrkMast, wrkMast.getSteNo(), crnProtocol);
                }
            }
        }
    }

    /**
     * 库位移转，回原库位
     */
    public void locToLoc17(CrnSlave slave, CrnProtocol crnProtocol){
        // 获取工作档信息
        WrkMast wrkMast = wrkMastMapper.selectLocMove17(slave.getId());
        if (null == wrkMast) {
            return;
        }

        //查找库位
        boolean flag = false;
        String[] deeplocs  = Utils.getDeepLocs(wrkMast.getSourceLocNo());
        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")){
                    flag = true;
                    break;
                }
                if(deepLoc != null && deepLoc.getLocSts().equals("O")){
                    //修改移库工作档
                    wrkMast.setSourceLocNo(wrkMast.getLocNo());
                    wrkMast.setIoPri((double)9999);
                    wrkMast.setWrkSts(2L);
                    wrkMast.setLocNo(deepLocNo);
                    wrkMast.setSteNo(null);
                    wrkMast.setModiTime(new Date());
                    if (wrkMastMapper.updateById(wrkMast) == 0) {
                        log.error("修改工作档状态 11.生成出库ID => 12.吊车出库中 失败！！，工作号={}", wrkMast.getWrkNo());
                    }

                    if(deepLoc.getLocSts().equals("O")){
                        deepLoc.setLocSts("S"); // S.入库预约
                        deepLoc.setModiTime(new Date());
                        if (!locMastService.updateById(deepLoc)) {
                            log.error("双深库位 --- 更新目标库位状态失败！ 待移转浅库位：" + deepLoc.getLocNo());
                            throw new CoolException("更新移库回库目标库位状态失败");
                        }
                    }
                    break;
                }
            }
        }
        if(flag){
            return;
        }

        // 获取源库位信息
        LocMast sourceLoc = locMastService.selectById(wrkMast.getSourceLocNo());
        if (null == sourceLoc) {
            log.error("工作档库位移转失败，原因：检索源库位失败！工作号={}，源库位={}", wrkMast.getWrkNo(), wrkMast.getSourceLocNo());
            return;
        }
        // 源库位  库位状态判断
        if (!sourceLoc.getLocSts().equals("R")) {
            return;
        }

        // 获取目标库位信息
        LocMast loc = locMastService.selectById(wrkMast.getLocNo());
        if (null == loc || !loc.getLocSts().equals("S")) {
            log.error("工作档库位移转失败，原因：检索目标库位失败！工作号={}，源库位={}", wrkMast.getWrkNo(), wrkMast.getLocNo());
            return;
        }

        // 获取堆垛机信息 并 判断是否可入出
        BasCrnp basCrnp = basCrnpService.selectById(slave.getId());
        if (!basCrnp.getInEnable().equals("Y") && !basCrnp.getOutEnable().equals("Y")) {
            return;
        }

        // 堆垛机控制过滤
        if (!crnProtocol.getStatusType().equals(CrnStatusType.IDLE) || crnProtocol.getTaskNo() != 0) {
            return;
        }

        // 已经存在吊车执行任务时，则过滤
        if (wrkMastMapper.selectWorking(slave.getId()) != null) {
            return;
        }

        // 置顶任务
        wrkMast.setIoPri((double) 9999);
        wrkMastMapper.updateById(wrkMast);

        // 源库位 ===>> 最外层库位
        if (locMastService.isOutMost(wrkMast.getSourceLocNo())) {
            // 目标库位 ===>> 最外层库位
            if (!locMastService.isOutMost(wrkMast.getLocNo())) {
                // 判断小车是否在当前组库位，如果是则将穿梭车移至最外层，等待堆垛机放货；如果不是，则堆垛机寻找穿梭车，并放置当前组最外层
                Integer steNo = this.hasCarOfIdle(wrkMast.getLocNo());
                // 有小车
                if (steNo != null) {
                    // 小车行走到堆垛机待搬移点
                    if (wrkMast.getWrkSts() == 2L && wrkMast.getSteNo() == null) {
                        // 没有其他任务
                        if (null == wrkMastMapper.selectPakin(slave.getId(), steNo)) {
                            this.letCarBeWaiting(wrkMast, steNo, wrkMast.getLocNo());
                        }
                    }
                    // 堆垛机将货放至小车上 3.小车待搬（小车不用搬运，已经在当前组库位） / 6.小车待入  ===>> 7.吊车入库中
                    if (wrkMast.getWrkSts() == 3L || wrkMast.getWrkSts() == 6L) {
                        // 小车处于空闲
                        SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, steNo);
                        SteProtocol steProtocol = steThread.getSteProtocol();
                        if (steProtocol == null) { return; }
                        if (steProtocol.isIdle()) {

                            // 已经存在吊车执行任务时，则过滤
                            if (wrkMastMapper.selectWorking(slave.getId()) != null) {
                                return;
                            }
                            // 堆垛机入库 命令下发区 --------------------------------------------------------------------------
                            CrnCommand crnCommand = new CrnCommand();
                            crnCommand.setCrnNo(slave.getId()); // 堆垛机编号
                            crnCommand.setTaskNo(wrkMast.getWrkNo().shortValue()); // 工作号
                            crnCommand.setAckFinish((short) 0);  // 任务完成确认位
                            crnCommand.setTaskMode(CrnTaskModeType.LOC_MOVE); // 任务模式:  库位移转
                            crnCommand.setSourcePosX(sourceLoc.getRow1().shortValue());     // 源库位排
                            crnCommand.setSourcePosY(sourceLoc.getBay1().shortValue());     // 源库位列
                            crnCommand.setSourcePosZ(sourceLoc.getLev1().shortValue());     // 源库位层
                            crnCommand.setDestinationPosX(Utils.getGroupRow(loc.getLocNo()).shortValue());     // 目标库位排
                            crnCommand.setDestinationPosY(loc.getBay1().shortValue());     // 目标库位列
                            crnCommand.setDestinationPosZ(loc.getLev1().shortValue());     // 目标库位层
                            if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getCrnNo(), new Task(2, crnCommand))) {
                                log.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
                            } else {
                                // 修改工作档状态  3.小车待搬 ===>> 7.吊车入库中
                                Date now = new Date();
                                wrkMast.setWrkSts(7L);
                                wrkMast.setCrnStrTime(now);
                                wrkMast.setModiTime(now);
                                if (wrkMastMapper.updateById(wrkMast) == 0) {
                                    log.error("修改工作档状态 3.小车待搬/6.小车待入 => 7.吊车入库中 失败！！，工作号={}", wrkMast.getWrkNo());
                                }
                                return;
                            }
                        }
                    }
                    // 没有小车
                } else {
                    if (wrkMast.getWrkSts() == 2L && wrkMast.getSteNo() == null) {
                        // 寻找当前堆垛机对应的小车
                        SteThread steThread = queryIdleCar(wrkMast);
                        if (steThread != null) {
                            // 没有其他任务
                            if (null == wrkMastMapper.selectPakin(slave.getId(), steNo)) {
                                // 让小车等待搬运待续
                                this.letCarBeReady(wrkMast, steThread.getSlave().getId(), wrkMast.getLocNo());
                            }
                        }
                    }
                    // 堆垛机搬运小车
                    if (wrkMast.getWrkSts() == 3L) {
                        this.carMoveIn(wrkMast, wrkMast.getSteNo(), crnProtocol);
                    }
                }
            }
        }
@@ -2028,59 +2247,8 @@
                    }
                // 库位移转
                } else {
                    if (wrkMast.getWrkSts() == 16) {
                        Date now = new Date();
//                        if (locMastService.isOutMost(wrkMast.getLocNo())) {
//                            // 16.吊车出库中 ==> 9.入库完成
//                            wrkMast.setWrkSts(9L);
//                            wrkMast.setCrnEndTime(now);
//                        } else {
//                            // 16.吊车出库中 ==> 9.入库完成
//                            wrkMast.setWrkSts(9L);
//                        }
                        if (locMastService.isOutMost(wrkMast.getLocNo())) {
                            wrkMast.setWrkSts(17L);
                        }
                        wrkMast.setModiTime(now);
                        // 修改成功后复位堆垛机
                        if (wrkMastMapper.updateById(wrkMast) > 0) {
                            // 堆垛机复位
                            crnThread.setResetFlag(true);
                        } else {
                            log.error("修改工作档状态 16.吊车出库中 失败！！，工作号={}", wrkMast.getWrkNo());
                        }
                    } else if (wrkMast.getWrkSts() == 4) {
                        // 4.迁入小车 ==> 6.小车待入
                        wrkMast.setWrkSts(6L);
                        Date now = new Date();
                        wrkMast.setCrnEndTime(now);
                        wrkMast.setModiTime(now);
                        // 修改成功后复位堆垛机
                        if (wrkMastMapper.updateById(wrkMast) > 0) {
                            // 堆垛机复位
                            crnThread.setResetFlag(true);
                            // 穿梭车重新定位排列层
                            SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, wrkMast.getSteNo());
                            if (!steThread.confirmPos()) {
                                log.error("{}号穿梭车重新定位失败！作业工作档任务号：{}", wrkMast.getSteNo(), wrkMast.getWrkNo());
                            }
                            // 穿梭车去待机位
                            BasSte basSte = basSteService.selectById(wrkMast.getSteNo());
                            SteCommand steCommand = new SteCommand();
                            steCommand.setSteNo(wrkMast.getSteNo()); // 穿梭车编号
                            steCommand.setTaskNo(9999); // 工作号
                            steCommand.setTaskMode(SteTaskModeType.findWaiting(basSte.getRow())); // 任务模式:  去近点 等待堆垛机叉取
//                        steCommand.setRow(Utils.getGroupRow(steProtocol.getRow().intValue()).shortValue());
//                        steCommand.setBay(steProtocol.getBay());
//                        steCommand.setLev(steProtocol.getLev());
                            if (!MessageQueue.offer(SlaveType.Ste, wrkMast.getSteNo(), new Task(2, steCommand))) {
                                log.error("穿梭车待机位命令下发失败，穿梭车号={}，任务数据={}", wrkMast.getSteNo(), JSON.toJSON(steCommand));
                            }
                        } else {
                            log.error("修改工作档状态 4.迁入小车 => 6.小车待入 失败！！，工作号={}", wrkMast.getWrkNo());
                        }
                        // 入库 ===>> 迁出小车 完成
                    } else if (wrkMast.getWrkSts() == 7){
                    // 入库 ==>> 货物搬入库
                    if (wrkMast.getWrkSts() == 7){
                        // 判断是否需要小车入库
                        if (locMastService.isOutMost(wrkMast.getLocNo())) {
                            // ==> 9.入库完成
@@ -2124,38 +2292,167 @@
                                }
                            }
                        }
                    } else if (wrkMast.getWrkSts() == 13) {
                        // 给穿梭车下发命令
                        Integer steNo = wrkMast.getSteNo();
                        SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, steNo);
                        SteProtocol steProtocol = steThread.getSteProtocol();
                        if (steProtocol == null) { continue; }
                        // 穿梭车重新定位排列层
                        if (!steThread.confirmPos()) {
                            log.error("{}号穿梭车重新定位失败！作业工作档任务号：{}", wrkMast.getSteNo(), wrkMast.getWrkNo());
                        }
                        // 命令下发区 --------------------------------------------------------------------------
                        SteCommand steCommand = new SteCommand();
                        steCommand.setSteNo(steNo); // 穿梭车编号
                        steCommand.setTaskNo(wrkMast.getWrkNo()); // 工作号
                        steCommand.setTaskMode(SteTaskModeType.findOutByLoc(wrkMast.getSourceLocNo())); // 任务模式:  搬出库
                        if (!MessageQueue.offer(SlaveType.Ste, steNo, new Task(2, steCommand))) {
                            log.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", steNo, JSON.toJSON(steCommand));
                        } else {
                            // 13.迁入小车 ==> 14.小车搬出库
                            wrkMast.setWrkSts(14L);
                            Date now = new Date();
                            wrkMast.setCrnEndTime(now);
                            wrkMast.setModiTime(now);
                            // 修改成功后复位堆垛机
                            if (wrkMastMapper.updateById(wrkMast) > 0) {
                                // 堆垛机复位
                                crnThread.setResetFlag(true);
                            } else {
                                log.error("修改工作档状态 13.迁入小车 ==> 14.小车搬出库 失败！！，工作号={}", wrkMast.getWrkNo());
                        // 入库 ===>> 迁入小车 完成
                    } else if (wrkMast.getWrkSts() == 4) {
                        // 4.迁入小车 ==> 6.小车待入
                        wrkMast.setWrkSts(6L);
                        Date now = new Date();
                        wrkMast.setCrnEndTime(now);
                        wrkMast.setModiTime(now);
                        // 修改成功后复位堆垛机
                        if (wrkMastMapper.updateById(wrkMast) > 0) {
                            // 堆垛机复位
                            crnThread.setResetFlag(true);
                            // 穿梭车重新定位排列层
                            SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, wrkMast.getSteNo());
                            if (!steThread.confirmPos()) {
                                log.error("{}号穿梭车重新定位失败！作业工作档任务号：{}", wrkMast.getSteNo(), wrkMast.getWrkNo());
                            }
                            // 穿梭车去待机位
                            BasSte basSte = basSteService.selectById(wrkMast.getSteNo());
                            SteCommand steCommand = new SteCommand();
                            steCommand.setSteNo(wrkMast.getSteNo()); // 穿梭车编号
                            steCommand.setTaskNo(9999); // 工作号
                            steCommand.setTaskMode(SteTaskModeType.findWaiting(basSte.getRow())); // 任务模式:  去近点 等待堆垛机叉取
//                        steCommand.setRow(Utils.getGroupRow(steProtocol.getRow().intValue()).shortValue());
//                        steCommand.setBay(steProtocol.getBay());
//                        steCommand.setLev(steProtocol.getLev());
                            if (!MessageQueue.offer(SlaveType.Ste, wrkMast.getSteNo(), new Task(2, steCommand))) {
                                log.error("穿梭车待机位命令下发失败，穿梭车号={}，任务数据={}", wrkMast.getSteNo(), JSON.toJSON(steCommand));
                            }
                        } else {
                            log.error("修改工作档状态 4.迁入小车 => 6.小车待入 失败！！，工作号={}", wrkMast.getWrkNo());
                        }
                        // 入库 ===>> 迁出小车 完成
                    }
//                    if (wrkMast.getWrkSts() == 16) {
//                        Date now = new Date();
////                        if (locMastService.isOutMost(wrkMast.getLocNo())) {
////                            // 16.吊车出库中 ==> 9.入库完成
////                            wrkMast.setWrkSts(9L);
////                            wrkMast.setCrnEndTime(now);
////                        } else {
////                            // 16.吊车出库中 ==> 9.入库完成
////                            wrkMast.setWrkSts(9L);
////                        }
//                        if (locMastService.isOutMost(wrkMast.getLocNo())) {
//                            wrkMast.setWrkSts(17L);
//                        }
//                        wrkMast.setModiTime(now);
//                        // 修改成功后复位堆垛机
//                        if (wrkMastMapper.updateById(wrkMast) > 0) {
//                            // 堆垛机复位
//                            crnThread.setResetFlag(true);
//                        } else {
//                            log.error("修改工作档状态 16.吊车出库中 失败！！，工作号={}", wrkMast.getWrkNo());
//                        }
//                    } else if (wrkMast.getWrkSts() == 4) {
//                        // 4.迁入小车 ==> 6.小车待入
//                        wrkMast.setWrkSts(6L);
//                        Date now = new Date();
//                        wrkMast.setCrnEndTime(now);
//                        wrkMast.setModiTime(now);
//                        // 修改成功后复位堆垛机
//                        if (wrkMastMapper.updateById(wrkMast) > 0) {
//                            // 堆垛机复位
//                            crnThread.setResetFlag(true);
//                            // 穿梭车重新定位排列层
//                            SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, wrkMast.getSteNo());
//                            if (!steThread.confirmPos()) {
//                                log.error("{}号穿梭车重新定位失败！作业工作档任务号：{}", wrkMast.getSteNo(), wrkMast.getWrkNo());
//                            }
//                            // 穿梭车去待机位
//                            BasSte basSte = basSteService.selectById(wrkMast.getSteNo());
//                            SteCommand steCommand = new SteCommand();
//                            steCommand.setSteNo(wrkMast.getSteNo()); // 穿梭车编号
//                            steCommand.setTaskNo(9999); // 工作号
//                            steCommand.setTaskMode(SteTaskModeType.findWaiting(basSte.getRow())); // 任务模式:  去近点 等待堆垛机叉取
////                        steCommand.setRow(Utils.getGroupRow(steProtocol.getRow().intValue()).shortValue());
////                        steCommand.setBay(steProtocol.getBay());
////                        steCommand.setLev(steProtocol.getLev());
//                            if (!MessageQueue.offer(SlaveType.Ste, wrkMast.getSteNo(), new Task(2, steCommand))) {
//                                log.error("穿梭车待机位命令下发失败，穿梭车号={}，任务数据={}", wrkMast.getSteNo(), JSON.toJSON(steCommand));
//                            }
//                        } else {
//                            log.error("修改工作档状态 4.迁入小车 => 6.小车待入 失败！！，工作号={}", wrkMast.getWrkNo());
//                        }
//                        // 入库 ===>> 迁出小车 完成
//                    } else if (wrkMast.getWrkSts() == 7){
//                        // 判断是否需要小车入库
//                        if (locMastService.isOutMost(wrkMast.getLocNo())) {
//                            // ==> 9.入库完成
//                            wrkMast.setWrkSts(9L);
//                            Date now = new Date();
//                            wrkMast.setCrnEndTime(now);
//                            wrkMast.setModiTime(now);
//                            // 修改成功后复位堆垛机
//                            if (wrkMastMapper.updateById(wrkMast) > 0) {
//                                // 堆垛机复位
//                                crnThread.setResetFlag(true);
//                            } else {
//                                log.error("修改工作档状态 7.吊车入库中 => 9.入库完成 失败！！，工作号={}", wrkMast.getWrkNo());
//                            }
//                        } else {
//                            // 给穿梭车下发命令
//                            Integer steNo = wrkMast.getSteNo();
//                            SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, steNo);
//                            SteProtocol steProtocol = steThread.getSteProtocol();
//                            if (steProtocol == null) { continue; }
//                            if (steProtocol.isIdle()) {
//                                // 命令下发区 --------------------------------------------------------------------------
//                                SteCommand steCommand = new SteCommand();
//                                steCommand.setSteNo(steNo); // 穿梭车编号
//                                steCommand.setTaskNo(wrkMast.getWrkNo()); // 工作号
//                                steCommand.setTaskMode(SteTaskModeType.findInByLoc(wrkMast.getLocNo())); // 任务模式: 搬入库
//                                if (!MessageQueue.offer(SlaveType.Ste, steNo, new Task(2, steCommand))) {
//                                    log.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", steNo, JSON.toJSON(steCommand));
//                                } else {
//                                    // 修改工作档状态 7.吊车入库中 => 8.小车搬入库
//                                    wrkMast.setWrkSts(8L);
//                                    Date now = new Date();
//                                    wrkMast.setCrnEndTime(now);
//                                    wrkMast.setModiTime(now);
//                                    if (wrkMastMapper.updateById(wrkMast) > 0) {
//                                        // 堆垛机复位
//                                        crnThread.setResetFlag(true);
//                                    } else {
//                                        log.error("修改工作档状态 7.吊车入库中 => 8.小车搬入库 失败！！，工作号={}", wrkMast.getWrkNo());
//                                    }
//                                }
//                            }
//                        }
//                    } else if (wrkMast.getWrkSts() == 13) {
//                        // 给穿梭车下发命令
//                        Integer steNo = wrkMast.getSteNo();
//                        SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, steNo);
//                        SteProtocol steProtocol = steThread.getSteProtocol();
//                        if (steProtocol == null) { continue; }
//                        // 穿梭车重新定位排列层
//                        if (!steThread.confirmPos()) {
//                            log.error("{}号穿梭车重新定位失败！作业工作档任务号：{}", wrkMast.getSteNo(), wrkMast.getWrkNo());
//                        }
//                        // 命令下发区 --------------------------------------------------------------------------
//                        SteCommand steCommand = new SteCommand();
//                        steCommand.setSteNo(steNo); // 穿梭车编号
//                        steCommand.setTaskNo(wrkMast.getWrkNo()); // 工作号
//                        steCommand.setTaskMode(SteTaskModeType.findOutByLoc(wrkMast.getSourceLocNo())); // 任务模式:  搬出库
//                        if (!MessageQueue.offer(SlaveType.Ste, steNo, new Task(2, steCommand))) {
//                            log.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", steNo, JSON.toJSON(steCommand));
//                        } else {
//                            // 13.迁入小车 ==> 14.小车搬出库
//                            wrkMast.setWrkSts(14L);
//                            Date now = new Date();
//                            wrkMast.setCrnEndTime(now);
//                            wrkMast.setModiTime(now);
//                            // 修改成功后复位堆垛机
//                            if (wrkMastMapper.updateById(wrkMast) > 0) {
//                                // 堆垛机复位
//                                crnThread.setResetFlag(true);
//                            } else {
//                                log.error("修改工作档状态 13.迁入小车 ==> 14.小车搬出库 失败！！，工作号={}", wrkMast.getWrkNo());
//                            }
//                        }
//                    }
                }
            }
        }
@@ -2247,23 +2544,23 @@
                                // 修改工作档状态 11.生成出库ID => 12.小车待搬
                                wrkMast.setWrkSts(12L);
                            } else {
                                if (Cools.isEmpty(wrkMast.getMk())) {
                                    log.error("移库工作档没有流程标记！！，工作号={}", wrkMast.getWrkNo());
                                } else {
                                    if (wrkMast.getMk().equals("I")) {
                                        String locNo = wrkMast.getLocNo();
                                        if (Utils.getGroupRow(locNo).equals(Utils.getGroupRow(steProtocol.getRow().intValue())) && steProtocol.getBay() == Utils.getBay(locNo) && steProtocol.getLev() == Utils.getLev(locNo)) {
                                            // 修改工作档状态 11.生成出库ID => 6.小车待入
                                            wrkMast.setWrkSts(6L);
                                        } else {
                                            // 修改工作档状态 11.生成出库ID => 3.小车待搬
                                            wrkMast.setWrkSts(3L);
                                        }
                                    } else if (wrkMast.getMk().equals("O")) {
                                        // 修改工作档状态 11.生成出库ID => 12.小车待搬
                                        wrkMast.setWrkSts(12L);
                                    }
                                }
//                                if (Cools.isEmpty(wrkMast.getMk())) {
//                                    log.error("移库工作档没有流程标记！！，工作号={}", wrkMast.getWrkNo());
//                                } else {
//                                    if (wrkMast.getMk().equals("I")) {
//                                        String locNo = wrkMast.getLocNo();
//                                        if (Utils.getGroupRow(locNo).equals(Utils.getGroupRow(steProtocol.getRow().intValue())) && steProtocol.getBay() == Utils.getBay(locNo) && steProtocol.getLev() == Utils.getLev(locNo)) {
//                                            // 修改工作档状态 11.生成出库ID => 6.小车待入
//                                            wrkMast.setWrkSts(6L);
//                                        } else {
//                                            // 修改工作档状态 11.生成出库ID => 3.小车待搬
//                                            wrkMast.setWrkSts(3L);
//                                        }
//                                    } else if (wrkMast.getMk().equals("O")) {
//                                        // 修改工作档状态 11.生成出库ID => 12.小车待搬
//                                        wrkMast.setWrkSts(12L);
//                                    }
//                                }
                            }
                            wrkMast.setModiTime(now);
                            if (wrkMastMapper.updateById(wrkMast) == 0) {
@@ -3093,5 +3390,99 @@

    }

    /**
     * 因深库位阻塞，对浅库位进行移转
     */
    private void moveLocForDeepLoc(CrnSlave crn, LocMast shallowLoc){
        try {
            String rows = "";
            switch (crn.getId()){
                case 1:
                    rows = "3,4";
                    break;
                case 2:
                    rows = "11,12";
                    break;
                case 3:
                    rows = "18,19";
                    break;
            }
            LocMast loc = locMastService.selectOne(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"));

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

            // 获取工作号
            int workNo = commonService.getWorkNo(0);
            Date now = new Date();
            // 保存工作档
            WrkMast wrkMast = new WrkMast();
            wrkMast.setWrkNo(workNo);
            wrkMast.setIoTime(now);
            wrkMast.setWrkSts(11L); // 工作状态：11.生成出库ID
            wrkMast.setIoType(11); // 入出库状态： 11.库格移载
            wrkMast.setIoPri((double) 9999);
            wrkMast.setCrnNo(crn.getId());
            wrkMast.setSourceLocNo(shallowLoc.getLocNo()); // 源库位
            wrkMast.setLocNo(loc.getLocNo()); // 目标库位
            wrkMast.setFullPlt(shallowLoc.getFullPlt()); // 满板
            wrkMast.setPicking("N"); // 拣料
            wrkMast.setExitMk("N"); // 退出
            wrkMast.setEmptyMk(shallowLoc.getLocSts().equals("D") ? "Y" : "N"); // 空板
            wrkMast.setBarcode(shallowLoc.getBarcode()); // 托盘码
            wrkMast.setLinkMis("N");
            wrkMast.setAppeTime(now);
            wrkMast.setModiTime(now);
            int res = wrkMastMapper.insert(wrkMast);
            if (res == 0) {
                throw new CoolException("保存工作档失败");
            }
            // 工作档明细保存
            if (shallowLoc.getLocSts().equals("F")) {
                List<LocDetl> locDetls = locDetlService.selectList(new EntityWrapper<LocDetl>().eq("loc_no", shallowLoc.getLocNo()));
                for (LocDetl locDetl : locDetls) {
                    WrkDetl wrkDetl = new WrkDetl();
                    wrkDetl.sync(locDetl);
                    wrkDetl.setWrkNo(workNo);
                    wrkDetl.setIoTime(new Date());
                    wrkDetl.setAnfme(locDetl.getAnfme());
                    wrkDetl.setAppeTime(new Date());
                    wrkDetl.setModiTime(new Date());
                    if (!wrkDetlService.insert(wrkDetl)) {
                        throw new CoolException("保存工作档明细失败");
                    }
                }
            }
            // 修改源库位状态
            if (shallowLoc.getLocSts().equals("D") || shallowLoc.getLocSts().equals("F")) {
                shallowLoc.setLocSts("R"); // R.出库预约
                shallowLoc.setModiTime(now);
                if (!locMastService.updateById(shallowLoc)) {
                    throw new CoolException("更新源库位状态失败");
                }
            } else {
                throw new CoolException("源库位出库失败");
            }
            // 修改目标库位状态
            if (loc.getLocSts().equals("O")) {
                loc.setLocSts("S"); // S.入库预约
                loc.setModiTime(now);
                if (!locMastService.updateById(loc)) {
                    throw new CoolException("更新目标库位状态失败");
                }
            } else {
                throw new CoolException("移转失败");
            }
        } catch (Exception e) {
            log.error("深库位阻塞，对浅库位进行移转失败", e);
            e.printStackTrace();
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
        }
    }

}

 src/main/java/com/zy/asrs/utils/Utils.java

@@ -225,7 +225,8 @@
    /**
     * 获取 深库位对应的浅库位组
     */
    public static String getShallowLocs(String deepLoc){
    public static String[] getShallowLocs(String deepLoc){
        String[] locsArr = null;
        String locs="";
        int row = getRow(deepLoc);
        switch (row){
@@ -270,13 +271,17 @@
                locs += zerofill(String.valueOf(row-1),2) + deepLoc.substring(2);
                break;
        }
        return locs;
        if(!Cools.isEmpty(locs)){
            locsArr = locs.split(",");
        }
        return locsArr;
    }

    /**
     * 获取 浅库位对应的深库位组
     */
    public static String getDeepLocs(String shallowLoc){
    public static String[] getDeepLocs(String shallowLoc){
        String[] locsArr = null;
        String locs="";
        int row = getRow(shallowLoc);
        switch (row){
@@ -288,19 +293,19 @@
            case 3:
            case 10:
            case 17:
                locs += zerofill(String.valueOf(row-1),2) + shallowLoc.substring(2);
                locs += "," + zerofill(String.valueOf(row-2),2) + shallowLoc.substring(2);
                locs += zerofill(String.valueOf(row-2),2) + shallowLoc.substring(2);
                locs += "," + zerofill(String.valueOf(row-1),2) + shallowLoc.substring(2);
                break;
            case 4:
                locs += zerofill(String.valueOf(row+1),2) + shallowLoc.substring(2);
                locs += zerofill(String.valueOf(row+3),2) + shallowLoc.substring(2);
                locs += "," + zerofill(String.valueOf(row+2),2) + shallowLoc.substring(2);
                locs += "," + zerofill(String.valueOf(row+3),2) + shallowLoc.substring(2);
                locs += "," + zerofill(String.valueOf(row+1),2) + shallowLoc.substring(2);
                break;
            case 5:
            case 12:
            case 19:
                locs += zerofill(String.valueOf(row+1),2) + shallowLoc.substring(2);
                locs += "," + zerofill(String.valueOf(row+2),2) + shallowLoc.substring(2);
                locs += zerofill(String.valueOf(row+2),2) + shallowLoc.substring(2);
                locs += "," + zerofill(String.valueOf(row+1),2) + shallowLoc.substring(2);
                break;
            case 6:
            case 13:
@@ -309,12 +314,15 @@
                break;
            case 11:
            case 18:
                locs += zerofill(String.valueOf(row-1),2) + shallowLoc.substring(2);
                locs += zerofill(String.valueOf(row-3),2) + shallowLoc.substring(2);
                locs += "," + zerofill(String.valueOf(row-2),2) + shallowLoc.substring(2);
                locs += "," + zerofill(String.valueOf(row-3),2) + shallowLoc.substring(2);
                locs += "," + zerofill(String.valueOf(row-1),2) + shallowLoc.substring(2);
                break;
        }
        return locs;
        if(!Cools.isEmpty(locs)){
            locsArr = locs.split(",");
        }
        return locsArr;
    }

    /**
@@ -340,17 +348,18 @@
    }

    public static void main(String[] args) {
        String shallowLocs = getShallowLocs("2100203");
        String deepLocs = getDeepLocs("2100203");
        System.out.println("shallowLocs ==>> " + shallowLocs);
        System.out.println("deepLocs ==>> " + deepLocs);
        String[] shallowArr = null, deepArr = null;
        if (shallowLocs.indexOf(',') >= 0) {
            shallowArr = shallowLocs.split(",");
        }
        if (deepLocs.indexOf(',') >= 0) {
            deepArr = deepLocs.split(",");
        }
//        String shallowLocs = getShallowLocs("2100203");
//        String deepLocs = getDeepLocs("2100203");
//        System.out.println("shallowLocs ==>> " + shallowLocs);
//        System.out.println("deepLocs ==>> " + deepLocs);
        String[] shallowArr = getShallowLocs("1700203");;
        String[] deepArr = getDeepLocs("1700203");
//        if (shallowLocs.indexOf(',') >= 0) {
//            shallowArr = shallowLocs.split(",");
//        }
//        if (deepLocs.indexOf(',') >= 0) {
//            deepArr = deepLocs.split(",");
//        }

        for(String str : deepArr){
            System.out.println(str);

 src/main/resources/mapper/WrkMastMapper.xml

@@ -158,4 +158,11 @@
        </if>
    </select>

    <select id="selectLocMoveWorking" resultMap="BaseResultMap">
        select top 1 * from dbo.asr_wrk_mast where crn_no=#{crnNo} and wrk_sts != 17 and io_type=11 order by io_pri desc,io_time,wrk_no asc
    </select>

    <select id="selectLocMove17" resultMap="BaseResultMap">
        select top 1 * from dbo.asr_wrk_mast where wrk_sts in (17) and io_type=11 and crn_no=#{crnNo} order by io_pri desc,io_time,wrk_no
    </select>
</mapper>