#

luxiaotao1123

2022-11-09 86f1da5c382460162d68d218e16057fe5be81d10

#

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

@@ -96,4 +96,7 @@
     * @return
     */
    WrkMast selectLocMove17(@Param("crnNo")Integer crnNo);

    WrkMast selectPick17(@Param("staNo") Integer staNo, @Param("wrkNo") Integer wrkNo);

}

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

@@ -470,13 +470,14 @@
                            if (wrkMastMapper.setSteEmpty(wrkMast.getWrkNo()) == 0) {
                                throw new CoolException(wrkMast.getWrkNo() + "更新工作档数据状态失败");
                            }
                            LocMast locMast = null;
                            // 修改源库位状态 O.空库位
                            LocMast locMast = locMastService.selectById(sourceLocNo);
                            locMast.setLocSts("O");
                            locMast.setModiTime(new Date());
                            if (!locMastService.updateById(locMast)) {
                                throw new CoolException(wrkMast.getWrkNo() + "修改源库位状态 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");
@@ -534,6 +535,47 @@
                }
            }

        }
    }

    /**
     * 盘点货物抵达盘点目标站 wrkMast.sourceLoc P ===>> O
     */
    public void pickWrkCompleteStaNo() {
        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.getWorkNo() > 0) {
                    WrkMast wrkMast = wrkMastMapper.selectPick17(pickSta.getStaNo(), staProtocol.getWorkNo().intValue());
                    if (Cools.isEmpty(wrkMast)) {
                        log.error("{}站拣料、并板、盘点检索任务失败！任务号：{}", pickSta.getStaNo(), staProtocol.getWorkNo());
                    } else {
                        // 修改源库位状态 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.空库位");
                            }
                        }
                        // 修改工作档
                        wrkMast.setIoPri(13D);
                        if (wrkMastMapper.updateById(wrkMast) == 0) {
                            log.error("更新工作档的优先级失败！！！ [工作号:{}]", wrkMast.getWrkNo());
                        }
                    }
                }

            }
        }
    }

@@ -1185,6 +1227,8 @@
                    }
                }

            } else {
                // todo
            }
            // 不是最外层库位，需要使用穿梭车搬运后，再堆垛机移库
        } else {
@@ -1287,43 +1331,53 @@
            return;
        }

        //查找库位
        boolean flag = false;
        String[] deeplocs  = Utils.getDeepLocs(wrkMast.getSourceLocNo());
        if(!Cools.isEmpty(deeplocs)){
            for(String deepLocNo : deeplocs) {
                LocMast deepLoc = locMastService.selectById(deepLocNo);
        if (wrkMast.getWrkSts() == 17) {
            //查找库位
            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 != null && !deepLoc.getLocSts().equals("F") && deepLoc.getLocSts().equals("D") && deepLoc.getLocSts().equals("O")){
                        flag = true;
                        break;
                    }

                    if(deepLoc.getLocSts().equals("O")){
                        deepLoc.setLocSts("S"); // S.入库预约
                        deepLoc.setModiTime(new Date());
                        if (!locMastService.updateById(deepLoc)) {
                            log.error("双深库位 --- 更新目标库位状态失败！ 待移转浅库位：" + deepLoc.getLocNo());
                            throw new CoolException("更新移库回库目标库位状态失败");
                    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("更新移库回库目标库位状态失败");
                            }
                        }
                        LocMast sourceLoc = locMastService.selectById(wrkMast.getSourceLocNo());
                        if(sourceLoc.getLocSts().equals("F")){
                            sourceLoc.setLocSts("R"); // R.出库预约
                            sourceLoc.setModiTime(new Date());
                            if (!locMastService.updateById(sourceLoc)) {
                                throw new CoolException("更新移库回库目标库位状态失败");
                            }
                        }
                        break;
                    }
                    break;
                }
            }
        }
        if(flag){
            return;
            if(flag){
                return;
            }
        }

        // 获取源库位信息
@@ -2325,134 +2379,134 @@
                        }
                        // 入库 ===>> 迁出小车 完成
                    }
//                    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 (wrkMast.getWrkSts() == 16) {
                        Date now = new Date();
//                        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.入库完成
//                            // 16.吊车出库中 ==> 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());
//                                    }
//                                }
//                            }
//                            // 16.吊车出库中 ==> 9.入库完成
//                            wrkMast.setWrkSts(9L);
//                        }
//                    } 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());
//                            }
//                        }
//                    }
                        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());
                            }
                        }
                    }
                }
            }
        }

 src/main/java/com/zy/core/MainProcess.java

@@ -52,6 +52,8 @@
                    // 拣料、并板、盘点再入库
                    mainService.stnToCrnStnPick0();
                    mainService.stnToCrnStnPick1();
                    // 拣料、并板、盘点抵达目标站
                    mainService.pickWrkCompleteStaNo();
                    // 出库  ===>>  堆垛机出库站到出库站
                    mainService.crnStnToOutStn();
                    // 入出库  ===>>  堆垛机入出库作业下发

 src/main/resources/application.yml

@@ -8,8 +8,8 @@
    name: @pom.build.finalName@
  datasource:
    driver-class-name: com.microsoft.sqlserver.jdbc.SQLServerDriver
#    url: jdbc:sqlserver://10.10.10.100:1433;databasename=bfasrs
    url: jdbc:sqlserver://192.168.4.15:1433;databasename=bfasrs
    url: jdbc:sqlserver://10.10.10.100:1433;databasename=bfasrs
#    url: jdbc:sqlserver://192.168.4.15:1433;databasename=bfasrs
    username: sa
    #    password: Zoneyung@zy56$
    password: sa@123

 src/main/resources/mapper/WrkMastMapper.xml

@@ -163,6 +163,12 @@
    </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 top 1 * from dbo.asr_wrk_mast where wrk_sts in (2,3,6,17) and io_type=11 and crn_no=#{crnNo} order by io_pri desc,io_time,wrk_no
    </select>

    <select id="selectPick17" resultMap="BaseResultMap">
        select * from dbo.asr_wrk_mast
        where 1=1 and (io_type=103 or io_type=107 or io_type=104) and wrk_sts = 17 and sta_no = #{staNo} and wrk_no = #{wrkNo}
    </select>

</mapper>