#

TQS

2023-04-20 f1b654fc854bd0a88ef7ee9815f8cfaf33e30007

#

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

@@ -60,6 +60,8 @@

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

    WrkMast selectWorking1(@Param("crnNo")Integer crnNo, @Param("wrkNo")Integer wrkNo);

    // work log -------------------------------------------------------
    @Insert("insert into asr_wrk_mast_log select * from asr_wrk_mast where wrk_no=#{workNo}")
    int saveWrkMastLog(Integer workNo);

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

@@ -114,33 +114,33 @@
                }
                Short workNo = staProtocol.getWorkNo();

                //20230201. 2号堆垛机有出库任务时，禁止新板入库
                if (staProtocol.isLoading() && staProtocol.getWorkNo() == 9995) {
                    if ( inSta.getStaNo()==103 && devpThread.ioModeOf1F == IoModeType.PAKOUT_MODE) {
                        //有出库任务，退库到入库口
                        staProtocol.setWorkNo((short) 9999);
                        staProtocol.setStaNo((short)100);
                        devpThread.setPakMk(staProtocol.getSiteId(), false);
                        boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
                        News.error("MainServiceImpl  generateStoreWrkFile"+"103为出库模式，禁止入库，退回入库口。！！！");
                        continue;
                    }
                    if ( inSta.getStaNo()==203 && devpThread.ioModeOf2F == IoModeType.PAKOUT_MODE) {
                        //有出库任务，退库到入库口
                        staProtocol.setWorkNo((short) 9999);
                        staProtocol.setStaNo((short)200);
                        devpThread.setPakMk(staProtocol.getSiteId(), false);
                        boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
                        News.error("MainServiceImpl  generateStoreWrkFile"+"203为出库模式，禁止入库，退回入库口。！！！");
                        continue;
                    }
                }

                // 判断是否满足入库条件
                if (staProtocol.isAutoing() && staProtocol.isLoading()
                        && staProtocol.isInEnable()
                        && !staProtocol.isEmptyMk() && (workNo == 0 || (workNo >= 9990 && workNo <= 9999))
                        && staProtocol.isPakMk()) {

                    //20230201. 2号堆垛机有出库任务时，禁止新板入库
                    if (staProtocol.getWorkNo() == 9995) {
                        if ( inSta.getStaNo()==103 && devpThread.ioModeOf1F == IoModeType.PAKOUT_MODE) {
                            //有出库任务，退库到入库口
                            staProtocol.setWorkNo((short) 9999);
                            staProtocol.setStaNo((short)100);
                            devpThread.setPakMk(staProtocol.getSiteId(), false);
                            boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
                            News.error("MainServiceImpl  generateStoreWrkFile"+"103为出库模式，禁止入库，退回入库口。！！！");
                            continue;
                        }
                        if ( inSta.getStaNo()==203 && devpThread.ioModeOf2F == IoModeType.PAKOUT_MODE) {
                            //有出库任务，退库到入库口
                            staProtocol.setWorkNo((short) 9999);
                            staProtocol.setStaNo((short)200);
                            devpThread.setPakMk(staProtocol.getSiteId(), false);
                            boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
                            News.error("MainServiceImpl  generateStoreWrkFile"+"203为出库模式，禁止入库，退回入库口。！！！");
                            continue;
                        }
                    }

                    // 获取条码扫描仪信息
                    BarcodeThread barcodeThread = (BarcodeThread) SlaveConnection.get(SlaveType.Barcode, inSta.getBarcode());
@@ -1097,7 +1097,7 @@
                            .last(" and wrk_sts>11 and io_type in (103,107) "));
                    if(!Cools.isEmpty(one)){
                        News.error("MainServiceImpl  1099行"+"存在捡料、盘点未入库货物，2号堆垛机暂时禁止出库！！！");
                        return false;
                        continue;
                    }
                }

@@ -1133,79 +1133,87 @@
                if(one.getWrkSts() > 10 && (Utils.getGroupRow(wrkMast.getSourceLocNo()) != Utils.getGroupRow(one.getSourceLocNo())
                        || Utils.getBay(wrkMast.getSourceLocNo()) != Utils.getBay(one.getSourceLocNo())
                        || Utils.getLev(wrkMast.getSourceLocNo()) != Utils.getLev(one.getSourceLocNo()))){
                    return false;
                    continue;
                }
                //存在移库任务，且在移回中，且移库目标库位与待出库库位不在同一库位组，时跳出，确保移库/出库全套任务完成后，再执行下一笔
                if(one.getWrkSts() < 11  && (Utils.getGroupRow(wrkMast.getSourceLocNo()) != Utils.getGroupRow(one.getLocNo())
                        || Utils.getBay(wrkMast.getSourceLocNo()) != Utils.getBay(one.getLocNo())
                        || Utils.getLev(wrkMast.getSourceLocNo()) != Utils.getLev(one.getLocNo()))){
                    return false;
                    continue;
                }
            }

            //出库库位不是最外层库位，判断浅库位组是否都为空，或存在库位移转任务
            boolean flag = false;
            if(!locMastService.isOutMost(wrkMast.getSourceLocNo())){
            if(!locMastService.isOutMost(wrkMast.getSourceLocNo())) {
                WrkMast wrkMastMove = wrkMastMapper.selectLocMoveWorking(slave.getId());
                if(wrkMastMove != null && wrkMast.getWrkNo() == 11){
                if (wrkMastMove != null && wrkMast.getWrkNo() == 11) {
                    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) {
                                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 (null == waitWrkMast) {
                                // 生成一笔移库任务工作档、改变浅库位的源库/目标库 库位状态
                                // 没有作业中的出库任务时，才能生成移库任务
                                WrkMast one2 = wrkMastService.selectOne(new EntityWrapper<WrkMast>()
                                        .eq("crn_no",slave.getId())
                                        .last(" and wrk_sts in (12,13,14,15,16)"));
                                if(one2==null) {
                                    moveLocForDeepLoc(slave, shallowLoc);
                WrkMast two = wrkMastMapper.selectWorking1(slave.getId(), wrkMast.getWrkNo());
                if (two != null) {//2号机有在执行任务时，禁止生成移库工作档
                    continue;
                } else {
                    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 {
                                    News.error("浅库位阻塞时，且浅库位存在作业中出库任务！工作号={}", one2.getWrkNo());
                                    //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;
                                    }
                                }
                                flag = true;
                                break;
                            } else {
                                if (waitWrkMast.getWrkSts()!=18) {
                                    News.error("库位出库到堆垛机站 ===>> 库位状态在库，但是浅库位已存在工作档任务！出库库位={},浅库位号={}", shallowLoc.getLocNo());
                            } else 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 (12,13,14,15,16)"));
                                    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;
                            }
                        } 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;
                            //20230307 ADD，再加一次判断，当浅库位状态不为O时，不执行当前出库任务
                            if (shallowLoc != null && !shallowLoc.getLocSts().equals("O")) {
                                News.error("做了浅库位阻塞处理后反复判断，浅库位状态不为O ===>> 浅库位库位状态为入库预约！出库库位={},浅库位号={}", wrkMast.getSourceLocNo(), shallowLoc.getLocNo());
                                flag = true;
                                break;
                            }
                        }
                    }
                }
@@ -1624,6 +1632,7 @@
            String locNo = Utils.append(row, bay, lev);
            String[] deeplocs  = Utils.getDeepLocs(locNo);
            if(!Cools.isEmpty(deeplocs)){
                boolean ret = false;
                for(String deepLocNo : deeplocs) {
                    LocMast deepLoc = locMastService.selectById(deepLocNo);
                    WrkMast waitWrkMast = wrkMastMapper.selectByLocNo1(deepLocNo);
@@ -1667,12 +1676,40 @@
                                throw new CoolException("更新移库回库目标库位状态失败");
                            }
                        }
                        ret = true;
                        break;
//                    } else {
//                        LocMast curLoc = locMastService.selectById(locNo);
//                        if(curLoc != null && curLoc.getLocSts().equals("O")){
//
//                        }
                    }
                }
                if(ret == false && !flag){//深库位都不为O
                    LocMast curLoc = locMastService.selectById(locNo);
                    if(curLoc != null && curLoc.getLocSts().equals("O")){
                        //修改移库工作档
                        wrkMast.setSourceLocNo(wrkMast.getLocNo());
                        wrkMast.setIoPri((double)9999);
                        wrkMast.setWrkSts(2L);
                        wrkMast.setLocNo(locNo);
                        wrkMast.setSteNo(0);
                        wrkMast.setModiTime(new Date());
                        if (wrkMastMapper.updateById(wrkMast) == 0) {
                            News.error("修改工作档状态 17.移库完成 => 2.移库再入库中 失败！！，工作号={}", wrkMast.getWrkNo());
                        }

                        if(curLoc.getLocSts().equals("O")){
                            curLoc.setLocSts("S"); // S.入库预约
                            curLoc.setModiTime(new Date());
                            if (!locMastService.updateById(curLoc)) {
                                News.error("双深库位 --- 更新目标库位状态失败！ 待移转浅库位：" + curLoc.getLocNo());
                                throw new CoolException("更新移库回库目标库位状态失败");
                            }
                        }
                        LocMast sourceLoc = locMastService.selectById(wrkMast.getSourceLocNo());
                        if(sourceLoc.getLocSts().equals("R") || sourceLoc.getLocSts().equals("D")){
                            sourceLoc.setLocSts("R"); // R.出库预约
                            sourceLoc.setModiTime(new Date());
                            if (!locMastService.updateById(sourceLoc)) {
                                throw new CoolException("更新移库回库目标库位状态失败");
                            }
                        }
                    }
                }
            }
@@ -1810,6 +1847,64 @@
                    if (wrkMast.getWrkSts() == 3L) {
                        this.carMoveIn(wrkMast, wrkMast.getSteNo(), crnProtocol);
                    }
                }
            } else { //2023-4-20， 最外层库位，搬走小车直接移库
                // 判断小车是否在最外层库位，如果是则搬走，如果不是，则直接堆垛机入库
                Integer steNo = this.hasCar(wrkMast.getLocNo());
                // 有小车
                if (steNo != null) {
                    // 小车行走到堆垛机待搬移点
                    if (wrkMast.getWrkSts() == 2L && wrkMast.getSteNo() == 0) {
                        // 没有其他任务
                        if (null == wrkMastMapper.selectPakin(slave.getId(), steNo)) {
                            this.letCarBeReady(wrkMast, steNo, wrkMast.getLocNo());
                        }
                    }
                    // 小车搬走
                    if (wrkMast.getWrkSts() == 3L) {
                        this.carMoveOut(wrkMast, steNo, crnProtocol);
                    }
                    // 没有小车
                } else {

                    // 当前入库库位组没有小车 堆垛机则去站点取货入库
                    // case 1：从始至终库位组都没有小车，没有迁出小车动作，所以工作状态 = 2
                    // case 2：堆垛机已经搬出小车，有迁出小车动作，所以工作状态 = 6
                    if (wrkMast.getWrkSts() == 2L && wrkMast.getSteNo() == 0) {

                        // 已经存在吊车执行任务时，则过滤
                        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.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(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))) {
                            News.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
                        } else {
                            // 修改工作档状态  7.吊车入库中
                            Date now = new Date();
                            wrkMast.setWrkSts(7L);
                            wrkMast.setCrnStrTime(now);
                            wrkMast.setModiTime(now);
                            if (wrkMastMapper.updateById(wrkMast) == 0) {
                                News.error("修改工作档状态 {} => 7.吊车入库中 失败！！，工作号={}", wrkMast.getWrkSts$(), wrkMast.getWrkNo());
                            }
                            return;
                        }
                    }

                }
            }
        }
@@ -2501,7 +2596,7 @@
                    // 充电任务
                    WrkCharge wrkCharge = wrkChargeService.selectById(crnProtocol.getTaskNo());
                    if (wrkCharge == null) {
                        News.error("堆垛机处于等待确认且任务完成状态，但未找到工作档。堆垛机号={}，工作号={}", crn.getId(), crnProtocol.getTaskNo());
                        News.error("堆垛机处于等待确认且任务完成状态，但未找到充电工作档。堆垛机号={}，工作号={}", crn.getId(), crnProtocol.getTaskNo());
                        continue;
                    } else {
                        // 小车搬至指定库位完成
@@ -2761,6 +2856,36 @@
                            News.error("修改工作档状态 4.迁入小车 => 6.小车待入 失败！！，工作号={}", wrkMast.getWrkNo());
                        }
                        // 入库 ===>> 迁出小车 完成
                    } else if (wrkMast.getWrkSts() == 5) {
                        // 5.迁出小车 ==> 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()) {
                                News.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))) {
                                News.error("穿梭车待机位命令下发失败，穿梭车号={}，任务数据={}", wrkMast.getSteNo(), JSON.toJSON(steCommand));
                            }
                        } else {
                            News.error("修改工作档状态 5.迁出小车 => 6.小车待入 失败！！，工作号={}", wrkMast.getWrkNo());
                        }
                    }
                    if (wrkMast.getWrkSts() == 16) {
                        Date now = new Date();
@@ -2946,10 +3071,11 @@
                News.info("ste[id={}] 收到等待WCS确认信号，但是任务号(地址V824)为0", steProtocol.getSteNo());
            }

            if (steProtocol.getWaiting() && steProtocol.getTaskNo() != 0 && steProtocol.getStatus() == 10) {
            if (steProtocol.getWaiting() && steProtocol.getTaskNo() != 0) {
                News.info("ste[id={}] 执行工作档完成，任务号={}, 穿梭车状态={}", steProtocol.getSteNo(), steProtocol.getTaskNo(), steProtocol.getStatus());
                if (steProtocol.getTaskNo() == 9999) {
                    steThread.setResetFlag(true);
                    News.info("ste[id={}]小车复位标记 9999 成功！！，工作号={}", steProtocol.getSteNo(), 9999);
                } else {
                    // 查询是否有待入库的任务
                    WrkMast wrkMast = wrkMastMapper.selectCarWaiting(steProtocol.getTaskNo().intValue());
@@ -2966,6 +3092,7 @@
                                    News.error("修改充电任务状态 21.准备充电 ===>> 22.小车待搬 失败！！，工作号={}", wrkCharge.getWrkNo());
                                } else {
                                    steThread.setResetFlag(true);
                                    News.info("ste[id={}]小车复位标记 21.准备充电 ===>> 22.小车待搬 成功！！，工作号={}", steProtocol.getSteNo(), wrkCharge.getWrkNo());
                                }
                            } else if (wrkCharge.getWrkSts() == 25) {
                                // 25.小车去充电 ===>> 26.等待充电
@@ -2974,6 +3101,7 @@
                                    News.error("修改充电任务状态 25.小车去充电 ===>> 26.等待充电 失败！！，工作号={}", wrkCharge.getWrkNo());
                                } else {
                                    steThread.setResetFlag(true);
                                    News.info("ste[id={}]小车复位标记 25.小车去充电 ===>> 26.等待充电 成功！！，工作号={}", steProtocol.getSteNo(), wrkCharge.getWrkNo());
                                }
                            }  else if (wrkCharge.getWrkSts() == 32) {
                                // 32.小车走行 ===>> 33.小车待搬
@@ -2982,6 +3110,7 @@
                                    News.error("修改演示任务状态 25.小车去充电 ===>> 26.等待充电 失败！！，工作号={}", wrkCharge.getWrkNo());
                                } else {
                                    steThread.setResetFlag(true);
                                    News.info("ste[id={}]小车复位标记 25.小车去充电 ===>> 26.等待充电 成功！！，工作号={}", steProtocol.getSteNo(), wrkCharge.getWrkNo());
                                }
                            } else if (wrkCharge.getWrkSts() == 36) {
                                // 36.小车走行 ===>> 37.演示完成
@@ -2990,9 +3119,13 @@
                                    News.error("修改演示任务状态 36.小车走行 ===>> 37.演示完成 失败！！，工作号={}", wrkCharge.getWrkNo());
                                } else {
                                    steThread.setResetFlag(true);
                                    News.info("ste[id={}]小车复位标记 36.小车走行 ===>> 37.演示完成 成功！！，工作号={}", steProtocol.getSteNo(), wrkCharge.getWrkNo());
                                }
                            }
                        }
                    }else{
                        News.info("ste[id={}] 执行工作档完成，任务号={}, 穿梭车状态={}，工作档状态={}",
                                steProtocol.getSteNo(), steProtocol.getTaskNo(), steProtocol.getStatus(), wrkMast.getWrkSts());
                    }

                    if (wrkMast == null) { continue; }
@@ -3002,9 +3135,10 @@
                            wrkMast.setWrkSts(3L);
                            wrkMast.setModiTime(now);
                            if (wrkMastMapper.updateById(wrkMast) == 0) {
                                News.error("修改工作档状态 2.设备上走 => 3.小车待搬 失败！！，工作号={}", wrkMast.getWrkNo());
                                News.error("ste[id={}] 修改工作档状态 2.设备上走 => 3.小车待搬 失败！！，工作号={}", steProtocol.getSteNo(), wrkMast.getWrkNo());
                            } else {
                                steThread.setResetFlag(true);
                                News.info("ste[id={}]小车复位标记 修改工作档状态 2.设备上走 => 3.小车待搬 成功！！，工作号={}", steProtocol.getSteNo(), wrkMast.getWrkNo());
                            }
                            break;
                        case 8:
@@ -3015,6 +3149,7 @@
                                News.error("修改工作档状态 8.小车搬入库 => 9.入库完成 失败！！，工作号={}", wrkMast.getWrkNo());
                            } else {
                                steThread.setResetFlag(true);
                                News.info("ste[id={}]小车复位标记 修改工作档状态 8.小车搬入库 => 9.入库完成 成功！！工作号={}", steProtocol.getSteNo(), wrkMast.getWrkNo());
                            }
                            break;
                        case 11:
@@ -3045,6 +3180,7 @@
                                News.error("修改工作档状态 11.生成出库ID => 12.小车待搬 失败！！，工作号={}", wrkMast.getWrkNo());
                            } else {
                                steThread.setResetFlag(true);
                                News.info("ste[id={}]小车复位标记 修改工作档状态 11.生成出库ID => 12.小车待搬 成功！！，工作号={}", steProtocol.getSteNo(), wrkMast.getWrkNo());
                            }
                            break;
                        case 14:
@@ -3055,6 +3191,7 @@
                                News.error("修改工作档状态 14.小车搬出库 => 15.等待吊车 失败！！，工作号={}", wrkMast.getWrkNo());
                            } else {
                                steThread.setResetFlag(true);
                                News.info("ste[id={}]小车复位标记 修改工作档状态 14.小车搬出库 => 15.等待吊车 成功！！，工作号={}", steProtocol.getSteNo(), wrkMast.getWrkNo());
                            }
                            break;
                    }
@@ -3679,6 +3816,7 @@
                                    News.error("修改充电任务状态 26.等待充电 ===> 28.完成充电 失败！！，工作号={}", wrkCharge.getWrkNo());
                                } else {
                                    steThread.setResetFlag(true);
                                    News.info("修改充电任务状态 26.等待充电 ===> 28.完成充电 成功！！，工作号={}", wrkCharge.getWrkNo());
                                }
                            }
                        } else {

 src/main/java/com/zy/core/thread/SiemensDevpThread.java

@@ -88,7 +88,8 @@
                        break;
                    // 写数据 ID+目标站
                    case 2:
                        write((StaProtocol)task.getData(), 0);
//                        write((StaProtocol)task.getData(), 0);
                        write((StaProtocol)task.getData());
                        Thread.sleep(300);
                        read();
                        break;
@@ -120,7 +121,7 @@
            OutputQueue.DEVP.offer(MessageFormat.format( "【{0}】输送线plc连接失败！！！ ===>> [id:{1}] [ip:{2}] [port:{3}]  [rack:{4}] [slot:{5}]", DateUtils.convert(new Date()), slave.getId(), slave.getIp(), slave.getPort(), slave.getRack(), slave.getSlot()));
            News.error("输送线plc连接失败！！！ ===>> [id:{}] [ip:{}] [port:{}]", slave.getId(), slave.getIp(), slave.getPort());
        }
        siemensS7Net.ConnectClose();
//        siemensS7Net.ConnectClose();
        return result;
    }

@@ -180,7 +181,7 @@
        }

        //读条码
        Thread.sleep(100);
        Thread.sleep(200);
        OperateResultExOne<byte[]> result2 = siemensS7Net.Read("DB100.100",(short)(barcodeSize*8));
        if (result2.IsSuccess) {
            for (int i = 0; i < barcodeSize; i++) {
@@ -194,7 +195,7 @@
        }

        // 充电信号位
        Thread.sleep(100);
        Thread.sleep(200);
        OperateResultExOne<byte[]> result3 = siemensS7Net.Read("DB102.50", (short)1);
        if (result3.IsSuccess) {
            boolean[] status = siemensS7Net.getByteTransform().TransBool(result3.Content, 0, 1);
@@ -232,8 +233,122 @@
    /**
     * 写入 ID+目标站 =====> 单站点写入
     */
    private void write(StaProtocol staProtocol) throws InterruptedException {
        if (null == staProtocol) {
            return;
        }
        int index = staNos.indexOf(staProtocol.getSiteId());

        OperateResult writeId,writeDest;
//        //任务ID下发次数
        int idCount = 0;
        boolean idFlag = false;
        while(idCount < 5){
            writeId = siemensS7Net.Write("DB100." + index*2, staProtocol.getWorkNo());    // 工作号
            if(writeId.IsSuccess){
                Thread.sleep(200);
                OperateResultExOne<byte[]> readId = siemensS7Net.Read("DB100." + index*2, (short)2);
                if(readId.IsSuccess){
                    short workNo = siemensS7Net.getByteTransform().TransInt16(readId.Content, 0);
                    if(staProtocol.getWorkNo().equals(workNo)){
                        //工作号写入成功
                        idFlag = true;
                        break;
                    } else {//返回结果是成功了，但是真实值不相同
                        idCount++;
                        OutputQueue.DEVP.offer(MessageFormat.format("【{0}】写入输送线工作号后返回成功，但是读取工作号值不一致。输送线plc编号={1}，站点数据={2},写入次数={3}",
                                slave.getId(), JSON.toJSON(staProtocol),idCount));
                        log.error("写入输送线工作号后返回成功，但是读取工作号值不一致。输送线plc编号={}，{}，写入次数={}", slave.getId(), JSON.toJSON(staProtocol), idCount);
                    }
                } else {
                    idCount++;
                    OutputQueue.DEVP.offer(MessageFormat.format("【{0}】写入输送线工作号后读取工作号失败。输送线plc编号={1}，站点数据={2},写入次数={3}",
                            slave.getId(), JSON.toJSON(staProtocol), idCount));
                    log.error("写入输送线工作号后读取工作号失败{}。输送线plc编号={}，站点数据={},写入次数={}", readId.Message, slave.getId(), JSON.toJSON(staProtocol), idCount);
                }
            } else {
                idCount++;
                OutputQueue.DEVP.offer(MessageFormat.format("【{0}】写入输送线工作号失败。输送线plc编号={1}，站点数据={2},写入次数={3}",
                        slave.getId(), JSON.toJSON(staProtocol),idCount));
                log.error("写入输送线工作号失败{}。输送线plc编号={}，站点数据={},写入次数={}", writeId.Message, slave.getId(), JSON.toJSON(staProtocol), idCount);
            }
            Thread.sleep(200);
        }

        //写ID尝试了5次还是失败了
        if(!idFlag){
            staProtocol = station.get(staProtocol.getSiteId());
            if (staProtocol.getWorkNo() == 0 && staProtocol.getStaNo() ==0) {
                staProtocol.setPakMk(true);
            }
            OutputQueue.DEVP.offer(MessageFormat.format("【{0}】写入输送线工作号尝试5次失败。输送线plc编号={1}，站点数据={2}", slave.getId(), JSON.toJSON(staProtocol)));
            log.error("写入输送线工作号尝试5次失败。输送线plc编号={}，站点数据={}", slave.getId(), JSON.toJSON(staProtocol));

            //重新添加数据到任务队列
            boolean result = MessageQueue.offer(SlaveType.Devp, slave.getId(), new Task(2, staProtocol));
//            read();//读取1次设备状态
            return;
        }

        //任务目标站下发次数
        int destCount = 0;
        boolean destFlag = false;
        while(destCount < 5){
            writeDest = siemensS7Net.Write("DB101." + index*2, staProtocol.getStaNo());    // 目标站
            if(writeDest.IsSuccess){
                Thread.sleep(200);
                OperateResultExOne<byte[]> readDest = siemensS7Net.Read("DB101." + index*2, (short)2);
                if(readDest.IsSuccess){
                    short staNo = siemensS7Net.getByteTransform().TransInt16(readDest.Content, 0);
                    if(staProtocol.getStaNo().equals(staNo)){
                        //目标站写入成功
                        destFlag = true;
                        break;
                    } else {//返回结果是成功了，但是真实值不相同
                        destCount++;
                        OutputQueue.DEVP.offer(MessageFormat.format("【{0}】写入输送线目标站后返回成功，但是读取目标站值不一致。输送线plc编号={1}，站点数据={2},写入次数={3}",
                                slave.getId(), JSON.toJSON(staProtocol),destCount));
                        log.error("写入输送线目标站后返回成功，但是读取目标站值不一致。输送线plc编号={}，{},写入次数={}", slave.getId(), JSON.toJSON(staProtocol), destCount);
                    }
                } else {
                    destCount++;
                    OutputQueue.DEVP.offer(MessageFormat.format("【{0}】写入输送线目标站后读取目标站失败。输送线plc编号={1}，站点数据={2},写入次数={3}",
                            slave.getId(), JSON.toJSON(staProtocol), destCount));
                    log.error("写入输送线目标站后读取目标站失败{}。输送线plc编号={}，站点数据={}，写入次数={}", readDest.Message, slave.getId(), JSON.toJSON(staProtocol), destCount);
                }
            } else {
                destCount++;
                OutputQueue.DEVP.offer(MessageFormat.format("【{0}】写入输送线目标站失败。输送线plc编号={1}，站点数据={2},写入次数={3}",
                        slave.getId(), JSON.toJSON(staProtocol),destCount));
                log.error("写入输送线目标站失败{}。输送线plc编号={}，站点数据={},写入次数={}", writeDest.Message, slave.getId(), JSON.toJSON(staProtocol), destCount);
            }
            Thread.sleep(200);
        }

        //写目标站尝试了5次还是失败了
        if(!destFlag){
            staProtocol = station.get(staProtocol.getSiteId());
            if (staProtocol.getWorkNo() == 0 && staProtocol.getStaNo() ==0) {
                staProtocol.setPakMk(true);
            }
            OutputQueue.DEVP.offer(MessageFormat.format("【{0}】写入输送线目标站尝试5次失败。输送线plc编号={1}，站点数据={2}", slave.getId(), JSON.toJSON(staProtocol)));
            log.error("写入输送线目标站尝试5次失败。输送线plc编号={}，站点数据={}", slave.getId(), JSON.toJSON(staProtocol));

            //重新添加数据到任务队列
            boolean result = MessageQueue.offer(SlaveType.Devp, slave.getId(), new Task(2, staProtocol));
//            read();//读取1次设备状态
            return;
        }

        OutputQueue.DEVP.offer(MessageFormat.format("【{0}】 输送线命令下发成功 [id:{1}] >>>>> {2}", DateUtils.convert(new Date()), slave.getId(), JSON.toJSON(staProtocol)));
        log.info("输送线命令下发 [id:{}] >>>>> 命令下发成功： {}",  slave.getId(), JSON.toJSON(staProtocol));
    }

    /**
     * 写入 ID+目标站 =====> 单站点写入
     */
    private void write(StaProtocol staProtocol, int times) throws InterruptedException {
        if (null == staProtocol || times > 2) {
        if (null == staProtocol || times > 3) {
            return;
        }
        int index = staNos.indexOf(staProtocol.getSiteId());
@@ -242,9 +357,9 @@
        OperateResult write1 = siemensS7Net.Write("DB101." + index*2, staProtocol.getStaNo());    // 目标站

        if (!write.IsSuccess || !write1.IsSuccess) {
            MessageQueue.offer(SlaveType.Devp, slave.getId(), new Task(2, staProtocol));
//            MessageQueue.offer(SlaveType.Devp, slave.getId(), new Task(2, staProtocol));
            OutputQueue.DEVP.offer(MessageFormat.format("【{0}】写入输送线站点数据失败。输送线plc编号={1}，站点数据={2}", slave.getId(), JSON.toJSON(staProtocol)));
            News.error("写入输送线站点数据失败，重新添加任务到队列。输送线plc编号={}，站点数据={}", slave.getId(), JSON.toJSON(staProtocol));
            News.error("写入输送线站点数据失败==>>{}--{}，重新添加任务到队列。输送线plc编号={}，站点数据={}", write.Message, write1.Message, slave.getId(), JSON.toJSON(staProtocol));
            times++;
            write(staProtocol, times);
//            staProtocol = station.get(staProtocol.getSiteId());
@@ -327,16 +442,7 @@
        slave.setRack(0);
        slave.setSlot(0);
        SiemensDevpThread devpThread = new SiemensDevpThread(slave);
        SiemensS7Net siemensS7Net = devpThread.getSiemensS7Net();
        siemensS7Net.setRack(slave.getRack().byteValue());
        siemensS7Net.setSlot(slave.getSlot().byteValue());
        OperateResult connect = siemensS7Net.ConnectServer();
        if(connect.IsSuccess){
            News.info("输送线plc连接成功 ===>> [id:{}] [ip:{}] [port:{}]", slave.getId(), slave.getIp(), slave.getPort());
        } else {
            News.error("输送线plc连接失败！！！ ===>> [id:{}] [ip:{}] [port:{}]", slave.getId(), slave.getIp(), slave.getPort());
        }
        siemensS7Net.ConnectClose();
        devpThread.connect();
        // 写
//        StaProtocol staProtocol = devpThread.getStation().get(1);
//        staProtocol.setWorkNo((short) 232);

 src/main/java/com/zy/core/thread/SteThread.java

@@ -67,8 +67,8 @@
                    // 写入数据
                    case 2:
                        write((SteCommand) task.getData());
                        Thread.sleep(200);
                        readStatus();
//                        Thread.sleep(200);
//                        readStatus();
                        break;
                    default:
                        break;
@@ -122,7 +122,7 @@
    /**
     * 读取状态
     */
    private void readStatus(){
    private synchronized void readStatus(){
        try {
            OperateResultExOne<byte[]> result = siemensS7Net.Read("V800", (short) 70);
            if (result.IsSuccess) {
@@ -183,13 +183,15 @@

                // 复位信号
                if (steProtocol.getWaiting()) {
                    News.error("-------------------------------------------第一步、[穿梭车号：{}, 工作号：{}]==>> 状态为{}，等待WCS确认！！",
                            slave.getId(),steProtocol.getTaskNo(),steProtocol.getStatus());
                    News.info("-------------第一步、[穿梭车号：{}, 工作号：{}]==>> 状态为{}，等待WCS确认！！{}",
                            slave.getId(),steProtocol.getTaskNo(),steProtocol.getStatus(), resetFlag);
                    if (resetFlag) {
                        SteCommand steCommand = new SteCommand();
                        steCommand.setComplete(true);
                        if (write(steCommand) && confirmPos()) {
                            resetFlag = false;
                            News.info("第二步、发送复位命令成功 resetFlag = false,[穿梭车号：{}, 工作号：{}]==>> 状态为{}，等待WCS确认！！{}",
                                    slave.getId(),steProtocol.getTaskNo(),steProtocol.getStatus(), resetFlag);
                        }
                    }
                }
@@ -227,7 +229,7 @@
    /**
     * 写入数据
     */
    private boolean write(SteCommand command){
    private synchronized boolean write(SteCommand command){
        if (null == command) {
            News.error("穿梭车写入命令为空");
            return false;
@@ -333,19 +335,19 @@
            if (result1.IsSuccess) {
                short taskNo = siemensS7Net.getByteTransform().TransInt16(result1.Content, 0);
                short taskType = siemensS7Net.getByteTransform().TransInt16(result1.Content, 2);
                readStatus();
//                readStatus();
                News.info("穿梭板任务下发成功后休眠200ms立即回读写入数据，穿梭板ID={}, 任务号={}, 作业类型={}",slave.getId(), taskNo, taskType);
                News.info("穿梭板任务下发成功后休眠200ms立即回读穿梭板状态，穿梭板ID={}, 任务号={}, 穿梭板状态={}",slave.getId(), steProtocol.getTaskNo(),steProtocol.getStatus());
            }

            resetFlag = false;
            return true;
        } else {
            OutputQueue.STE.offer(MessageFormat.format("【{0}】写入穿梭车plc数据失败 ===>> [id:{1}] [ip:{2}] [port:{3}]", DateUtils.convert(new Date()), slave.getId(), slave.getIp(), slave.getPort()));
            News.error("写入穿梭车plc数据失败 ===>> [id:{}] [ip:{}] [port:{}]", slave.getId(), slave.getIp(), slave.getPort());

            //写入失败后，重新添加commanddao 任务队列中,并立即回读一次设备状态
            MessageQueue.offer(SlaveType.Ste, slave.getId(), new Task(2, command));
            readStatus();
//            MessageQueue.offer(SlaveType.Ste, slave.getId(), new Task(2, command));
//            readStatus();

            initSte();
            return false;

 src/main/resources/mapper/WrkMastMapper.xml

@@ -136,6 +136,12 @@
        select top 1 * from dbo.asr_wrk_mast where 1=1 and (wrk_sts=7 or wrk_sts=16) and crn_no=#{crnNo} order by io_time,wrk_no
    </select>

    <select id="selectWorking1" resultMap="BaseResultMap">
        select top 1 * from dbo.asr_wrk_mast
        where 1=1 and wrk_no!=#{wrkNo} and ((wrk_sts>11 and wrk_sts &lt; 17) or (wrk_sts=11 and ste_no is not null and ste_no>0)) and crn_no=#{crnNo}
        order by io_time,wrk_no
    </select>

    <select id="selectPakin" resultMap="BaseResultMap">
        select top 1 * from dbo.asr_wrk_mast
        where 1=1