高频入出库模式

Junjie

2023-05-31 8c97f18015743c7f913b9c512bdc768d144c575e

高频入出库模式

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

@@ -56,6 +56,8 @@
//    @Select("select top 1 * from dbo.asr_wrk_mast where wrk_sts=11 and (io_type=11 or io_type=110) and crn_no=#{crnNo} order by io_time,wrk_no")
    WrkMast selectLocMove(@Param("crnNo")Integer crnNo);

    WrkMast selectLocMove111(@Param("crnNo")Integer crnNo);

    WrkMast selectLocMoving(@Param("crnNo")Integer crnNo);

    WrkMast selectWorking(@Param("crnNo")Integer crnNo);

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

@@ -789,7 +789,7 @@
                continue;
            }
            // 只有当堆垛机空闲 并且 无任务时才继续执行
            if (crnProtocol.getStatusType() == CrnStatusType.IDLE && crnProtocol.getTaskNo() == 0 && crnProtocol.getModeType() == CrnModeType.AUTO) {
            if (true || crnProtocol.getStatusType() == CrnStatusType.IDLE && crnProtocol.getTaskNo() == 0 && crnProtocol.getModeType() == CrnModeType.AUTO) {
                // 如果最近一次是入库模式
                if (crnProtocol.getLastIo().equals("I")) {
                    if (basCrnp.getInEnable().equals("Y")) {
@@ -820,6 +820,8 @@
                }
                // 库位移转
                this.locToLoc1(crn, crnProtocol);
                // 库位移转(高频移库，io_type=111)
                this.locToLoc111(crn, crnProtocol);
                // 库位移转，回原库位
                this.locToLoc17(crn, crnProtocol);
                // 演示任务
@@ -866,6 +868,67 @@
            if(!Cools.isEmpty(one)){
                News.error("入库 ===>> 存在移库未完成任务，不能入库。移库任务号={},堆垛机号={}", one.getWrkNo(), slave.getId());
//                continue;
            }

            //入库库位不是最外层库位，判断最外层库位是否为空库位，如不是则进行移库任务
            if(!locMastService.isOutMost(wrkMast.getLocNo())) {
                WrkMast wrkMastMove = wrkMastMapper.selectLocMoveWorking(slave.getId());
                if (wrkMastMove != null && wrkMast.getWrkNo() == 111) {
                    continue;
                }

                WrkMast two = wrkMastMapper.selectWorking1(slave.getId(), wrkMast.getWrkNo());
                if (two != null) {//2号机有在执行任务时，禁止生成移库工作档
                    continue;
                } else {
                    List<String> shallowLocs = Utils.getShallowLocs(wrkMast.getLocNo());
                    if (!Cools.isEmpty(shallowLocs)) {
                        for (String shallowLocNo : shallowLocs) {
                            LocMast shallowLoc = locMastService.selectById(shallowLocNo);
                            WrkMast waitWrkMast = wrkMastMapper.selectByLocNo(shallowLocNo);
                            if (shallowLoc.getLocSts().equals("F") || shallowLoc.getLocSts().equals("D")) {
                                if (null == waitWrkMast) {
                                    // 生成一笔移库任务工作档、改变浅库位的源库/目标库 库位状态
                                    // 没有作业中的入库任务时，才能生成移库任务
                                    WrkMast one2 = wrkMastService.selectOne(new EntityWrapper<WrkMast>()
                                            .eq("crn_no", slave.getId())
                                            .last(" and wrk_sts in (3,4,5,6,7,8)"));
                                    if (one2 == null) {
                                        moveLocForDeepLoc(slave, shallowLoc);
                                        // 置顶任务
                                        wrkMast.setIoPri((double) 9999);
                                        wrkMastMapper.updateById(wrkMast);
                                    } else {
                                        News.error("浅库位阻塞时，且浅库位存在作业中出库任务！工作号={}", one2.getWrkNo());
                                    }
                                    flag = true;
                                    break;
                                } else {
                                    if (waitWrkMast.getWrkSts() != 18) {
                                        News.error("库位出库到堆垛机站 ===>> 库位状态在库，但是浅库位已存在工作档任务！出库库位={},浅库位号={}", shallowLoc.getLocNo());
                                        flag = true;
                                        break;
                                    }

                                }
                            } else if (shallowLoc.getLocSts().equals("Q") || shallowLoc.getLocSts().equals("S")) {
                                News.error("库位出库到堆垛机站 ===>> 浅库位库位状态为入库预约！出库库位={},浅库位号={}", shallowLoc.getLocNo());
                                flag = true;
                                break;
                            }

                            //20230307 ADD，再加一次判断，当浅库位状态不为O时，不执行当前出库任务
                            if (shallowLoc != null && !shallowLoc.getLocSts().equals("O")) {
                                News.error("做了浅库位阻塞处理后反复判断，浅库位状态不为O ===>> 浅库位库位状态为入库预约！出库库位={},浅库位号={}", wrkMast.getSourceLocNo(), shallowLoc.getLocNo());
                                flag = true;
                                break;
                            }
                        }
                    }
                }
            }
            if(flag){
                return false;
            }

            // 判断是否已存在小车绑定任务
@@ -1148,11 +1211,11 @@
                }
            }

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

@@ -1160,29 +1223,12 @@
                if (two != null) {//2号机有在执行任务时，禁止生成移库工作档
                    continue;
                } else {
                    String[] shallowlocs = Utils.getShallowLocs(wrkMast.getSourceLocNo());
                    if (!Cools.isEmpty(shallowlocs)) {
                        for (String shallowLocNo : shallowlocs) {
                    List<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) {
                                    News.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) {
                                            News.error("调整工作档优先级失败！工作号={}", waitWrkMast.getWrkNo());
                                        }
                                        if (waitWrkMast.getWrkSts() != 17) {
                                            flag = true;
                                        }
                                        break;
                                    }
                                }
                            } else if (shallowLoc.getLocSts().equals("F") || shallowLoc.getLocSts().equals("D")) {
                            if (shallowLoc.getLocSts().equals("F") || shallowLoc.getLocSts().equals("D")) {
                                if (null == waitWrkMast) {
                                    // 生成一笔移库任务工作档、改变浅库位的源库/目标库 库位状态
                                    // 没有作业中的出库任务时，才能生成移库任务
@@ -1612,6 +1658,102 @@
                if (wrkMast.getWrkSts() == 12L) {
                    this.carMoveIn(wrkMast, wrkMast.getSteNo(), crnProtocol);
                }
            }
        }
    }

    /**
     * 库位移转(高频移库，io_type=111)
     */
    public synchronized void locToLoc111(CrnSlave slave, CrnProtocol crnProtocol){
        // 获取工作档信息
        WrkMast wrkMast = wrkMastMapper.selectLocMove111(slave.getId());
        if (null == wrkMast) {
            return;
        }
        // 过滤
        if (null != wrkMastMapper.selectPakin(slave.getId(), null)) {
            News.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 != 111 and wrk_sts < 10"));
        if(one != null){
            News.error("{}移库任务无法作业，因入库任务已绑定小车!", wrkMast.getWrkNo());
            return;
        }

        // 获取源库位信息
        LocMast sourceLoc = locMastService.selectById(wrkMast.getSourceLocNo());
        if (null == sourceLoc) {
            News.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")) {
            News.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())) {
                // 命令下发区 --------------------------------------------------------------------------
                CrnCommand crnCommand = new CrnCommand();
                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());     // 源库位列
                crnCommand.setSourcePosZ(sourceLoc.getLev1().shortValue());     // 源库位层
                crnCommand.setDestinationPosX(loc.getRow1().shortValue());     // 目标库位排
                crnCommand.setDestinationPosY(loc.getBay1().shortValue());     // 目标库位列
                crnCommand.setDestinationPosZ(loc.getLev1().shortValue());     // 目标库位层
                if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getCrnNo(), new Task(2, crnCommand))) {
                    News.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
                } else {
                    // 修改工作档状态 11.生成出库ID => 7.吊车入库中
                    Date now = new Date();
                    wrkMast.setWrkSts(7L);
                    wrkMast.setCrnStrTime(now);
                    wrkMast.setModiTime(now);
                    if (wrkMastMapper.updateById(wrkMast) == 0) {
                        News.error("【库位移转】 修改工作档状态 11.生成出库ID => 7.吊车入库中 失败！！，工作号={}", wrkMast.getWrkNo());
                    }
                }

            }
        }
    }
@@ -2638,7 +2780,7 @@

                }
                if (wrkMast == null) { continue; }
                if (wrkMast.getIoType() != 11) {
                if (wrkMast.getIoType() != 11 && wrkMast.getIoType() != 111) {
                    // 入库 ==>> 货物搬入库
                    if (wrkMast.getWrkSts() == 7){
                        // 判断是否需要小车入库
@@ -2782,8 +2924,52 @@
                        }
                        // 移库 ===>> 堆垛机搬至目标库位组 完成
                    }
                // 库位移转(高频io_type111)
                } else if(wrkMast.getIoType() == 111) {
                    Date now = new Date();
                    // 入库 ==>> 货物搬入库
                    if (wrkMast.getWrkSts() == 7){
                        if (locMastService.isOutMost(wrkMast.getLocNo()) && locMastService.isOutMost(wrkMast.getSourceLocNo())) {
                            // ==> 9.入库完成
                            wrkMast.setWrkSts(9L);
                            wrkMast.setCrnEndTime(now);
                            wrkMast.setModiTime(now);
                            // 修改成功后复位堆垛机
                            if (wrkMastMapper.updateById(wrkMast) > 0) {

//                                if (!locDetlService.updateLocNo(wrkMast.getLocNo(), wrkMast.getSourceLocNo())) {
//                                    News.error("库位移转 ===>> 转移库存明细数据失败；[源库位={}],[目标库位={}]", wrkMast.getSourceLocNo(), wrkMast.getLocNo());
//                                    continue;
//                                }

//                                // 修改源库位状态 ==> O
//                                LocMast sourceLoc = locMastService.selectById(wrkMast.getSourceLocNo());
//                                if (null != sourceLoc) {
//                                    sourceLoc.setLocSts("O");
//                                    sourceLoc.setModiTime(now);
//                                    if (!locMastService.updateById(sourceLoc)) {
//                                        News.error("库位移转 ===>> 修改源库位状态失败；[workNo={}],[sourceLoc={}]", wrkMast.getWrkNo(), wrkMast.getSourceLocNo());
//                                    }
//                                }
//                                // 修改目标库位状态 ==> F
//                                LocMast locMast = locMastService.selectById(wrkMast.getLocNo());
//                                if (locMast != null) {
//                                    locMast.setLocSts("F");
//                                    locMast.setModiTime(now);
//                                    if (!locMastService.updateById(locMast)) {
//                                        News.error("库位移转 ===>> 修改目标库位状态失败；[workNo={}],[locNo={}]", wrkMast.getWrkNo(), wrkMast.getLocNo());
//                                    }
//                                }

                                // 堆垛机复位
                                crnThread.setResetFlag(true);
                            } else {
                                News.error("修改工作档状态 7.吊车入库中 => 9.入库完成 失败！！，工作号={}", wrkMast.getWrkNo());
                            }
                        }
                    }
                // 库位移转
                } else {
                }else {
                    // 入库 ==>> 货物搬入库
                    if (wrkMast.getWrkSts() == 7){
                        // 判断是否需要小车入库
@@ -4057,6 +4243,7 @@
            LocMast loc = null;
            List<LocMast> locs = locMastService.selectList(new EntityWrapper<LocMast>().eq("crn_no",crn.getId())
                                                .eq("loc_type1",shallowLoc.getLocType1())
                                                .eq("loc_type2",shallowLoc.getLocType2())
                                                .eq("loc_sts","O")
                                                .last(" and row1 in (" + rows + ") order by bay1,lev1"));
            for (LocMast one : locs){
@@ -4064,30 +4251,8 @@
                    || Utils.getBay(one.getLocNo()) != Utils.getBay(shallowLoc.getLocNo())
                    || Utils.getLev(one.getLocNo()) != Utils.getLev(shallowLoc.getLocNo())){

                    boolean success = true;
                    List<String> insideLoc = Utils.getGroupInsideLoc(one.getLocNo());
                    for (String inside : insideLoc) {
                        LocMast locMast = locMastService.selectById(inside);
                        if(Cools.isEmpty(locMast)){
                            continue;
                        }
                        if (locMast.getLocSts().equals("P")
                                || locMastService.selectById(inside).getLocSts().equals("R")
                                || locMastService.selectById(inside).getLocSts().equals("S")
                                || locMastService.selectById(inside).getLocSts().equals("Q")) {
                            success = false; break;
                        }
                    }

                    Integer steNo = this.hasCar(one.getLocNo());
                    if (steNo != null) {
                        continue;
                    }

                    if (success) {
                        loc = one;
                        break;
                    }
                    loc = one;
                    break;
                }
            }

@@ -4104,7 +4269,7 @@
            wrkMast.setWrkNo(workNo);
            wrkMast.setIoTime(now);
            wrkMast.setWrkSts(11L); // 工作状态：11.生成出库ID
            wrkMast.setIoType(11); // 入出库状态： 11.库格移载
            wrkMast.setIoType(111); // 入出库状态： 111.库格移载(高频)
            wrkMast.setIoPri((double) 9999);
            wrkMast.setCrnNo(crn.getId());
            wrkMast.setSourceLocNo(shallowLoc.getLocNo()); // 源库位

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

@@ -6,6 +6,7 @@

import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/**
@@ -224,56 +225,180 @@
    /**
     * 获取 深库位对应的浅库位组
     */
    public static String[] getShallowLocs(String deepLoc){
        String[] locsArr = null;
        String locs="";
        int row = getRow(deepLoc);
    public static List<String> getShallowLocs(String locNo){
        int row = getRow(locNo);
        switch (row){
            case 1:
                locs += zerofill(String.valueOf(row+2),2) + deepLoc.substring(2);
                locs += "," + zerofill(String.valueOf(row+1),2) + deepLoc.substring(2);
                break;
                return new ArrayList<String>() {{
                    add(zerofill(String.valueOf(2), 2) + locNo.substring(2));
                    add(zerofill(String.valueOf(3), 2) + locNo.substring(2));
                }};
            case 2:
                locs += zerofill(String.valueOf(row+1),2) + deepLoc.substring(2);
                break;
                return new ArrayList<String>() {{
                    add(zerofill(String.valueOf(3), 2) + locNo.substring(2));
                }};
            case 3:
            case 4:
                return null;
            case 5:
            case 20:
                locs += zerofill(String.valueOf(row-1),2) + deepLoc.substring(2);
                break;
                return new ArrayList<String>() {{
                    add(zerofill(String.valueOf(4), 2) + locNo.substring(2));
                }};
            case 6:
            case 14:
            case 21:
                locs += zerofill(String.valueOf(row-2),2) + deepLoc.substring(2);
                locs += "," + zerofill(String.valueOf(row-1),2) + deepLoc.substring(2);
                break;
                return new ArrayList<String>() {{
                    add(zerofill(String.valueOf(5), 2) + locNo.substring(2));
                    add(zerofill(String.valueOf(4), 2) + locNo.substring(2));
                }};
            case 7:
                locs += zerofill(String.valueOf(row-3),2) + deepLoc.substring(2);
                locs += "," + zerofill(String.valueOf(row-2),2) + deepLoc.substring(2);
                locs += "," + zerofill(String.valueOf(row-1),2) + deepLoc.substring(2);
                break;
                return new ArrayList<String>() {{
                    add(zerofill(String.valueOf(6), 2) + locNo.substring(2));
                    add(zerofill(String.valueOf(5), 2) + locNo.substring(2));
                    add(zerofill(String.valueOf(4), 2) + locNo.substring(2));
                }};
            case 8:
            case 15:
                locs += zerofill(String.valueOf(row+3),2) + deepLoc.substring(2);
                locs += "," + zerofill(String.valueOf(row+2),2) + deepLoc.substring(2);
                locs += "," + zerofill(String.valueOf(row+1),2) + deepLoc.substring(2);
                break;
                return new ArrayList<String>() {{
                    add(zerofill(String.valueOf(9), 2) + locNo.substring(2));
                    add(zerofill(String.valueOf(10), 2) + locNo.substring(2));
                    add(zerofill(String.valueOf(11), 2) + locNo.substring(2));
                }};
            case 9:
            case 16:
                locs += zerofill(String.valueOf(row+2),2) + deepLoc.substring(2);
                locs += "," + zerofill(String.valueOf(row+1),2) + deepLoc.substring(2);
                break;
                return new ArrayList<String>() {{
                    add(zerofill(String.valueOf(10), 2) + locNo.substring(2));
                    add(zerofill(String.valueOf(11), 2) + locNo.substring(2));
                }};
            case 10:
            case 17:
                locs += zerofill(String.valueOf(row+1),2) + deepLoc.substring(2);
                break;
                return new ArrayList<String>() {{
                    add(zerofill(String.valueOf(11), 2) + locNo.substring(2));
                }};
            case 11:
            case 12:
                return null;
            case 13:
                locs += zerofill(String.valueOf(row-1),2) + deepLoc.substring(2);
                break;
                return new ArrayList<String>() {{
                    add(zerofill(String.valueOf(12), 2) + locNo.substring(2));
                }};
            case 14:
                return new ArrayList<String>() {{
                    add(zerofill(String.valueOf(13), 2) + locNo.substring(2));
                    add(zerofill(String.valueOf(12), 2) + locNo.substring(2));
                }};
            case 15:
                return new ArrayList<String>() {{
                    add(zerofill(String.valueOf(16), 2) + locNo.substring(2));
                    add(zerofill(String.valueOf(17), 2) + locNo.substring(2));
                    add(zerofill(String.valueOf(18), 2) + locNo.substring(2));
                }};
            case 16:
                return new ArrayList<String>() {{
                    add(zerofill(String.valueOf(17), 2) + locNo.substring(2));
                    add(zerofill(String.valueOf(18), 2) + locNo.substring(2));
                }};
            case 17:
                return new ArrayList<String>() {{
                    add(zerofill(String.valueOf(18), 2) + locNo.substring(2));
                }};
            case 18:
            case 19:
                return null;
            case 20:
                return new ArrayList<String>() {{
                    add(zerofill(String.valueOf(19), 2) + locNo.substring(2));
                }};
            case 21:
                return new ArrayList<String>() {{
                    add(zerofill(String.valueOf(20), 2) + locNo.substring(2));
                    add(zerofill(String.valueOf(19), 2) + locNo.substring(2));
                }};
            default:
                throw new RuntimeException("库位解析异常");
        }
        if(!Cools.isEmpty(locs)){
            locsArr = locs.split(",");
//        String[] locsArr = null;
//        String locs="";
//        int row = getRow(deepLoc);
//        switch (row){
//            case 1:
//                locs += zerofill(String.valueOf(row+2),2) + deepLoc.substring(2);
//                locs += "," + zerofill(String.valueOf(row+1),2) + deepLoc.substring(2);
//                break;
//            case 2:
//                locs += zerofill(String.valueOf(row+1),2) + deepLoc.substring(2);
//                break;
//            case 5:
//            case 20:
//                locs += zerofill(String.valueOf(row-1),2) + deepLoc.substring(2);
//                break;
//            case 6:
//            case 14:
//            case 21:
//                locs += zerofill(String.valueOf(row-2),2) + deepLoc.substring(2);
//                locs += "," + zerofill(String.valueOf(row-1),2) + deepLoc.substring(2);
//                break;
//            case 7:
//                locs += zerofill(String.valueOf(row-3),2) + deepLoc.substring(2);
//                locs += "," + zerofill(String.valueOf(row-2),2) + deepLoc.substring(2);
//                locs += "," + zerofill(String.valueOf(row-1),2) + deepLoc.substring(2);
//                break;
//            case 8:
//            case 15:
//                locs += zerofill(String.valueOf(row+3),2) + deepLoc.substring(2);
//                locs += "," + zerofill(String.valueOf(row+2),2) + deepLoc.substring(2);
//                locs += "," + zerofill(String.valueOf(row+1),2) + deepLoc.substring(2);
//                break;
//            case 9:
//            case 16:
//                locs += zerofill(String.valueOf(row+2),2) + deepLoc.substring(2);
//                locs += "," + zerofill(String.valueOf(row+1),2) + deepLoc.substring(2);
//                break;
//            case 10:
//            case 17:
//                locs += zerofill(String.valueOf(row+1),2) + deepLoc.substring(2);
//                break;
//            case 13:
//                locs += zerofill(String.valueOf(row-1),2) + deepLoc.substring(2);
//                break;
//        }
//        if(!Cools.isEmpty(locs)){
//            locsArr = locs.split(",");
//        }
//        return locsArr;
    }

    /**
     * 获取当前库位巷道最外侧库位号
     */
    public static String getGroupOutermostLoc(String locNo) {
        int row = getRow(locNo);
        switch (row) {
            case 1:
            case 2:
            case 3:
                return zerofill(String.valueOf(3), 2) + locNo.substring(2);
            case 4:
            case 5:
            case 6:
            case 7:
                return zerofill(String.valueOf(4), 2) + locNo.substring(2);
            case 8:
            case 9:
            case 10:
            case 11:
                return zerofill(String.valueOf(11), 2) + locNo.substring(2);
            case 12:
            case 13:
            case 14:
                return zerofill(String.valueOf(12), 2) + locNo.substring(2);
            case 15:
            case 16:
            case 17:
            case 18:
                return zerofill(String.valueOf(18), 2) + locNo.substring(2);
            case 19:
            case 20:
            case 21:
                return zerofill(String.valueOf(19), 2) + locNo.substring(2);
            default:
                throw new RuntimeException("库位解析异常");
        }
        return locsArr;
    }

    /**
@@ -351,8 +476,10 @@
//        String deepLocs = getDeepLocs("2100203");
//        System.out.println("shallowLocs ==>> " + shallowLocs);
//        System.out.println("deepLocs ==>> " + deepLocs);
        String[] shallowArr = getShallowLocs("1700203");;
//        String[] shallowArr = getShallowLocs("0300504");
        List<String> shallowLocs = getShallowLocs("2100404");
        String[] deepArr = getDeepLocs("1700203");
        String outermostLoc = getGroupOutermostLoc("0701703");
//        if (shallowLocs.indexOf(',') >= 0) {
//            shallowArr = shallowLocs.split(",");
//        }

 src/main/resources/mapper/WrkMastMapper.xml

@@ -128,6 +128,10 @@
        select top 1 * from dbo.asr_wrk_mast where wrk_sts in (3,6,11,12,15) and io_type=11 and crn_no=#{crnNo} order by io_pri desc,io_time,wrk_no
    </select>

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

    <select id="selectLocMoving" resultMap="BaseResultMap">
        select top 1 * from dbo.asr_wrk_mast where wrk_sts=12 and io_type=11 and crn_no=#{crnNo} order by io_time,wrk_no
    </select>