#1

dubin

2025-11-27 2ea423b0f01d4db3d879066cd6c9634cc6800c7c

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

@@ -136,7 +136,9 @@
                        && staProtocol.isInEnable()
                        && !staProtocol.isEmptyMk()
                        && staProtocol.getWorkNo() == 9999
                        && staProtocol.isPakMk() && (staProtocol.getEmptyInType() != 1 && staProtocol.getEmptyInType() != 2)) {
                        && staProtocol.isPakMk()
//                        && (staProtocol.getEmptyInType() != 1 && staProtocol.getEmptyInType() != 2)
                ) {
                    News.warnNoLog("" + mark + " - 0" + " - 开始执行");

                    String barcode = barcodeThread.getBarcode();
@@ -197,17 +199,17 @@
                        continue;
                    }

                    if (inSta.getStaNo() == 1005) {
                        //检测是否有出库任务
                        List<WrkMast> wrkMasts = wrkMastService.selectList(new EntityWrapper<WrkMast>()
                                .in("io_type", 101, 103, 107)
                                .in("sta_no", 1003, 1007)
                        );
                        if (!wrkMasts.isEmpty()) {
                            News.error("" + mark + " - 4" + " - 1003站入库，检测存在出库任务，等待出库任务执行完成,托盘码={}", barcode);
                            continue;
                        }
                    }
//                    if (inSta.getStaNo() == 1002 || inSta.getStaNo() == 1007) {
//                        //检测是否有出库任务
//                        List<WrkMast> wrkMasts = wrkMastService.selectList(new EntityWrapper<WrkMast>()
//                                .in("io_type", 101, 103, 107)
//                                .in("sta_no", 1003, 1004)
//                        );
//                        if (!wrkMasts.isEmpty()) {
//                            News.error("" + mark + " - 4" + " - 入库，检测存在出库任务，等待出库任务执行完成,托盘码={}", barcode);
//                            continue;
//                        }
//                    }

                    try {
                        LocTypeDto locTypeDto = new LocTypeDto(staProtocol);
@@ -232,14 +234,14 @@

                            short staNo = dto.getStaNo().shortValue();

                            int sourceStaNo = dto.getSourceStaNo();
                            if (sourceStaNo == 1007) {
                                staNo = 2002;
                            }

                            if (inSta.getStaNo() == 1002) {
                                staNo = 2002;
                            }
//                            int sourceStaNo = dto.getSourceStaNo();
//                            if (sourceStaNo == 1007) {
//                                staNo = 2002;
//                            }
//
//                            if (inSta.getStaNo() == 1002) {
//                                staNo = 2002;
//                            }

                            barcodeThread.setBarcode("");
                            staProtocol.setWorkNo(dto.getWorkNo().shortValue());
@@ -409,20 +411,31 @@
                            // 无拣料数据
                            continue;
                        }

                        if (wrkMast.getIoType() == 53 || wrkMast.getIoType() == 57) {
                            if (wrkMast.getWrkSts() != 2) {
                                News.error("" + mark + " - 3" + " - 拣选盘点回库工作档状态异常！！！ [plc编号：{}]", devp.getId());
                                continue;
                            }

                            LocMast locMast = locMastService.selectById(wrkMast.getLocNo());
                            // 更新站点信息 且 下发plc命令
                            staProtocol.setWorkNo(wrkMast.getWrkNo().shortValue());
                            staProtocol.setStaNo(wrkMast.getStaNo().shortValue());
                            staProtocol.setPalletSize(locMast.getLocType2());
                            devpThread.setPakMk(staProtocol.getSiteId(), false);
                            boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
                            if (!result) {
                                News.error("" + mark + " - 3" + " - 发布命令至输送线队列失败！！！ [plc编号：{}]", devp.getId());
                            }
                            continue;
                        }

                        if ((wrkMast.getIoType() != 103 && wrkMast.getIoType() != 104 && wrkMast.getIoType() != 107)
                                || Cools.isEmpty(wrkMast.getStaNo()) || Cools.isEmpty(wrkMast.getSourceStaNo())) {
                            continue;
                        }

                        // 拣、盘、并 作业站转换
//                    int stnNo = 0;
//                    if (wrkMast.getStaNo() == 109) {
//                        stnNo = 127;
//                    } else if (wrkMast.getStaNo() == 113) {
//                        stnNo = 128;
//                    } else {
//                        log.error("{}号任务数据异常！", wrkMast.getWrkNo());
//                    }
                        // 获取目标站
                        Wrapper<StaDesc> wrapper = new EntityWrapper<StaDesc>()
                                .eq("type_no", wrkMast.getIoType() - 50)
@@ -446,62 +459,58 @@
                        }

                        try {
                            // 保存工作明细档历史档
                            if (wrkMastMapper.saveWrkDetlLog(wrkMast.getWrkNo()) == 0) {
                                throw new CoolException("保存工作明细档历史档失败");
                            }
                            // 保存工作主档历史档
                            if (wrkMastMapper.saveWrkMastLog(wrkMast.getWrkNo()) == 0) {
                                throw new CoolException("保存工作主档历史档失败");
                            }
                            LocTypeDto locTypeDto = new LocTypeDto(staProtocol);

                            Date now = new Date();
                            // 堆垛机站点(目标站)
                            Integer staNo = staDesc.getCrnStn();
                            // 更新工作档数据状态
                            wrkMast.setIoTime(now);
                            wrkMast.setIoType(wrkMast.getIoType() - 50); // 入出库类型: 103->53,104->54,107->57
                            wrkMast.setWrkSts(2L); // 工作状态: 2.设备上走
                            wrkMast.setSourceStaNo(wrkMast.getStaNo()); // 源站
                            wrkMast.setStaNo(staNo); // 目标站
                            wrkMast.setLocNo(wrkMast.getSourceLocNo()); // 目标库位 = 出库时的源库位
                            wrkMast.setSourceLocNo(""); // 源库位清空
                            wrkMast.setModiTime(now);
                            wrkMast.setUpdMk("");//允许再次移库
                            if (wrkMastMapper.updateById(wrkMast) == 0) {
                                throw new CoolException("更新工作档数据状态失败");
                            }
                            // 更新明细档io_time (历史档关联使用）
                            wrkDetlService.updateIoTime(wrkMast.getWrkNo(), now);
                            // 修改库位状态 Q.拣料/盘点/并板再入库
                            LocMast locMast = locMastService.selectById(wrkMast.getLocNo());
                            locMast.setLocSts("Q");
                            locMast.setModiTime(new Date());
                            if (!locMastService.updateById(locMast)) {
                                throw new CoolException("修改库位状态失败");
                            SearchLocParam param = new SearchLocParam();
                            param.setBarcode(wrkMast.getBarcode());
                            param.setSourceStaNo(pickSta.getStaNo());
                            param.setLocType1(locTypeDto.getLocType1());
                            String response = new HttpHandler.Builder()
                                    .setUri(wmsUrl)
                                    .setPath("/rpc/pakin/pick/loc/v1")
                                    .setJson(JSON.toJSONString(param))
                                    .build()
                                    .doPost();
                            JSONObject jsonObject = JSON.parseObject(response);
                            if (jsonObject.getInteger("code").equals(200)) {
                                WrkMast newWrkMast = wrkMastMapper.selectPakInStepBarcode(wrkMast.getBarcode());
                                if (newWrkMast == null) {
                                    // 无拣料数据
                                    News.error("" + mark + " - 3" + " - 拣选盘点回库获取工作档失败！！！ [plc编号：{}]", devp.getId());
                                    continue;
                                }

                                if(newWrkMast.getWrkSts() != 53 && newWrkMast.getWrkSts() != 57) {
                                    News.error("" + mark + " - 3" + " - 拣选盘点回库工作档类型异常！！！ [plc编号：{}]", devp.getId());
                                    continue;
                                }

                                if (wrkMast.getWrkSts() != 2) {
                                    News.error("" + mark + " - 3" + " - 拣选盘点回库工作档状态异常！！！ [plc编号：{}]", devp.getId());
                                    continue;
                                }

                                LocMast locMast = locMastService.selectById(newWrkMast.getLocNo());
                                // 更新站点信息 且 下发plc命令
                                staProtocol.setWorkNo(newWrkMast.getWrkNo().shortValue());
                                staProtocol.setStaNo(newWrkMast.getStaNo().shortValue());
                                staProtocol.setPalletSize(locMast.getLocType2());
                                devpThread.setPakMk(staProtocol.getSiteId(), false);
                                boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
                                if (!result) {
                                    News.error("" + mark + " - 3" + " - 发布命令至输送线队列失败！！！ [plc编号：{}]", devp.getId());
                                }
                            } else {
                                News.error("" + mark + " - 5" + " - 请求接口失败！！！url：{}；request：{}；response：{}", wmsUrl + "/rpc/pakin/pick/loc/v1", JSON.toJSONString(param), response);
                            }
                        } catch (Exception e) {
                            e.printStackTrace();
                            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                            continue;
                        }

                        LocMast locMast = locMastService.selectById(wrkMast.getLocNo());
                        // 更新站点信息 且 下发plc命令
                        staProtocol.setWorkNo(wrkMast.getWrkNo().shortValue());
                        staProtocol.setStaNo(wrkMast.getStaNo().shortValue());
                        staProtocol.setPalletSize(locMast.getLocType2());
                        devpThread.setPakMk(staProtocol.getSiteId(), false);
                        boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
                        if (!result) {
                            News.error("" + mark + " - 3" + " - 发布命令至输送线队列失败！！！ [plc编号：{}]", devp.getId());
                        }

                    } else {
                        News.errorNoLog("" + mark + " - 6" + " - 站点信息不符合入库条件！！！" + " 自动信号：" + staProtocol.isLoading() + "、可入信号：" + staProtocol.isInEnable()
                                + "、空板信号：" + staProtocol.isEmptyMk());
                    }

                }

            }
@@ -708,9 +717,14 @@
                    LocMast locMast = locMastService.selectOne(new EntityWrapper<LocMast>()
                            .eq("loc_no", wrkMast.getSourceLocNo()));

                    short staNo = wrkMast.getStaNo().shortValue();
                    if (wrkMast.getStaNo() == 1004) {
                        staNo = 2003;
                    }

                    // 下发站点信息
                    staProtocol.setWorkNo(wrkMast.getWrkNo().shortValue());
                    staProtocol.setStaNo(wrkMast.getStaNo().shortValue());
                    staProtocol.setStaNo(staNo);
                    staProtocol.setPalletSize(locMast.getLocType2());
                    if (!MessageQueue.offer(SlaveType.Devp, devpId, new Task(2, staProtocol))) {
                        continue;
@@ -1003,16 +1017,16 @@
                continue;
            }

            if (crnProtocol.getCrnNo() == 1) {
                //判断堆垛机和当前任务是否处于一个巷道
                if (Utils.getLaneByLocNo(wrkMast.getLocNo()) != crnProtocol.getCrnLane()) {
                    //判断堆垛机所在巷道是否存在其他任务，如存在则优先执行
                    List<WrkMast> currentWrkMasts = wrkMastService.selectLaneWrkMast(crnProtocol.getCrnLane(), false);
//                    if (!currentWrkMasts.isEmpty()) {
//                        continue;//当前堆垛机所在巷道存在任务
//                    }
                }
            }
//            if (crnProtocol.getCrnNo() == 1) {
//                //判断堆垛机和当前任务是否处于一个巷道
//                if (Utils.getLaneByLocNo(wrkMast.getLocNo()) != crnProtocol.getCrnLane()) {
//                    //判断堆垛机所在巷道是否存在其他任务，如存在则优先执行
//                    List<WrkMast> currentWrkMasts = wrkMastService.selectLaneWrkMast(crnProtocol.getCrnLane(), false);
////                    if (!currentWrkMasts.isEmpty()) {
////                        continue;//当前堆垛机所在巷道存在任务
////                    }
//                }
//            }

            // 双深库位且浅库位有货，则需先对浅库位进行库位移转
            if (Utils.isDeepLoc(slaveProperties, wrkMast.getLocNo())) {
@@ -1119,32 +1133,32 @@
    public synchronized void locToCrnStn(CrnSlave slave, CrnProtocol crnProtocol, Integer mark) {
        News.warnNoLog("" + mark + " - 2" + " - 0" + " - 堆垛机入出库作业下发：执行出库");

        int devpTaskStackOver = 20;
        Config config = configService.selectOne(new EntityWrapper<Config>()
                .eq("code", "devpTaskStackOver"));
        if (config != null) {
            devpTaskStackOver = Integer.parseInt(config.getValue());
        }
        int devpCheckTaskStackOver = 2;
        Config config2 = configService.selectOne(new EntityWrapper<Config>()
                .eq("code", "devpCheckTaskStackOver"));
        if (config2 != null) {
            devpCheckTaskStackOver = Integer.parseInt(config2.getValue());
        }

        int outNumber = 13;
        Config config3 = configService.selectOne(new EntityWrapper<Config>()
                .eq("code", "fullBoardOutboundNumber"));
        if (config3 != null) {
            outNumber = Integer.parseInt(config3.getValue());
        }


        Integer devpWorkingCount = commonService.queryDevpWorkingCount();
        if (devpWorkingCount > devpTaskStackOver) {
            News.warn("" + mark + " - 2" + " - 0" + " - 输送线任务过载，当前输送线承载数量:{}", devpWorkingCount);
            return;
        }
//        int devpTaskStackOver = 20;
//        Config config = configService.selectOne(new EntityWrapper<Config>()
//                .eq("code", "devpTaskStackOver"));
//        if (config != null) {
//            devpTaskStackOver = Integer.parseInt(config.getValue());
//        }
//        int devpCheckTaskStackOver = 2;
//        Config config2 = configService.selectOne(new EntityWrapper<Config>()
//                .eq("code", "devpCheckTaskStackOver"));
//        if (config2 != null) {
//            devpCheckTaskStackOver = Integer.parseInt(config2.getValue());
//        }
//
//        int outNumber = 13;
//        Config config3 = configService.selectOne(new EntityWrapper<Config>()
//                .eq("code", "fullBoardOutboundNumber"));
//        if (config3 != null) {
//            outNumber = Integer.parseInt(config3.getValue());
//        }
//
//
//        Integer devpWorkingCount = commonService.queryDevpWorkingCount();
//        if (devpWorkingCount > devpTaskStackOver) {
//            News.warn("" + mark + " - 2" + " - 0" + " - 输送线任务过载，当前输送线承载数量:{}", devpWorkingCount);
//            return;
//        }

        for (CrnSlave.CrnStn crnStn : slave.getCrnOutStn()) {
            // 获取工作状态为11（生成出库ID）的出库工作档
@@ -1176,48 +1190,49 @@
                    staProtocol = staProtocol.clone();
                }

                if (wrkMast.getStaNo() == 1003 || wrkMast.getStaNo() == 1007) {
                    //检测是否有入库任务
                    List<WrkMast> inWrkMasts = wrkMastService.selectList(new EntityWrapper<WrkMast>()
                            .in("io_type", 1, 53, 57)
                            .in("source_sta_no", 1005)
                    );
                    if (!inWrkMasts.isEmpty()) {
                        News.error("" + mark + " - 2" + " - 检测存在入库任务，等待入库任务执行完成再出库，工作号={}" + wrkMast.getWrkNo());
                        continue;
                    }
                }
//                if (wrkMast.getStaNo() == 1003 || wrkMast.getStaNo() == 1007 || wrkMast.getStaNo() == 1004) {
//                    //检测是否有入库任务
//                    List<WrkMast> inWrkMasts = wrkMastService.selectList(new EntityWrapper<WrkMast>()
//                            .in("io_type", 1, 53, 57)
//                            .notIn("wrk_sts", 3, 4, 5)
//                            .in("source_sta_no", 1002, 1007)
//                    );
//                    if (!inWrkMasts.isEmpty()) {
//                        News.error("" + mark + " - 2" + " - 检测存在入库任务，等待入库任务执行完成再出库，工作号={}" + wrkMast.getWrkNo());
//                        continue;
//                    }
//                }

                //zhangc
                if (wrkMast.getIoType() == 103 || wrkMast.getIoType() == 107) {
                    if (wrkMast.getStaNo() == 1058) {
                        List<WrkMast> inWrkMasts = wrkMastService.selectList(new EntityWrapper<WrkMast>()
                                .in("wrk_sts", 12, 14)
                                .eq("sta_no", 1058)
                        );
                        if (!Cools.isEmpty(inWrkMasts) && inWrkMasts.size() >= devpCheckTaskStackOver) {
                            News.error("" + mark + " - 2" + " - 检测存在1058站点，存在两笔工作中的任务，工作号={}" + wrkMast.getWrkNo());
                            continue;
                        }
                    } else if (wrkMast.getStaNo() == 1062) {
                        List<WrkMast> inWrkMasts = wrkMastService.selectList(new EntityWrapper<WrkMast>()
                                .in("wrk_sts", 12, 14)
                                .eq("sta_no", 1062)
                        );
                        if (!Cools.isEmpty(inWrkMasts) && inWrkMasts.size() >= devpCheckTaskStackOver) {
                            News.error("" + mark + " - 2" + " - 检测存在1062站点，存在两笔工作中的任务，工作号={}" + wrkMast.getWrkNo());
                            continue;
                        }
                    }
                }else if (wrkMast.getIoType() == 101) {
                    List<WrkMast> inWrkMasts = wrkMastService.selectList(new EntityWrapper<WrkMast>()
                            .in("wrk_sts", 12, 14)
                    );
                    if (!Cools.isEmpty(inWrkMasts) && inWrkMasts.size() >= outNumber) {
                        News.error("" + mark + " - 4" + " - 检测到全板出库的任务已经到达上线，工作号={}" + wrkMast.getWrkNo());
                        continue;
                    }
                }
//                if (wrkMast.getIoType() == 103 || wrkMast.getIoType() == 107) {
//                    if (wrkMast.getStaNo() == 1058) {
//                        List<WrkMast> inWrkMasts = wrkMastService.selectList(new EntityWrapper<WrkMast>()
//                                .in("wrk_sts", 12, 14)
//                                .eq("sta_no", 1058)
//                        );
//                        if (!Cools.isEmpty(inWrkMasts) && inWrkMasts.size() >= devpCheckTaskStackOver) {
//                            News.error("" + mark + " - 2" + " - 检测存在1058站点，存在两笔工作中的任务，工作号={}" + wrkMast.getWrkNo());
//                            continue;
//                        }
//                    } else if (wrkMast.getStaNo() == 1062) {
//                        List<WrkMast> inWrkMasts = wrkMastService.selectList(new EntityWrapper<WrkMast>()
//                                .in("wrk_sts", 12, 14)
//                                .eq("sta_no", 1062)
//                        );
//                        if (!Cools.isEmpty(inWrkMasts) && inWrkMasts.size() >= devpCheckTaskStackOver) {
//                            News.error("" + mark + " - 2" + " - 检测存在1062站点，存在两笔工作中的任务，工作号={}" + wrkMast.getWrkNo());
//                            continue;
//                        }
//                    }
//                }else if (wrkMast.getIoType() == 101) {
//                    List<WrkMast> inWrkMasts = wrkMastService.selectList(new EntityWrapper<WrkMast>()
//                            .in("wrk_sts", 12, 14)
//                    );
//                    if (!Cools.isEmpty(inWrkMasts) && inWrkMasts.size() >= outNumber) {
//                        News.error("" + mark + " - 4" + " - 检测到全板出库的任务已经到达上线，工作号={}" + wrkMast.getWrkNo());
//                        continue;
//                    }
//                }

//            // 入出库模式判断
//            if (devpThread.ioMode != IoModeType.PAKOUT_MODE) { continue; }
@@ -1237,22 +1252,22 @@
                if (staProtocol.isAutoing() && !staProtocol.isLoading() && staDetl.getCanouting() != null && staDetl.getCanouting().equals("Y")) {

                    //根据参数判断是否校验可出信号
                    String crnOutVerifyOut = "Y";
                    Config crnOutVerifyOutEnableConfig = configService.selectOne(new EntityWrapper<Config>()
                            .eq("code", "crnOutVerifyOutEnable"));
                    if (crnOutVerifyOutEnableConfig != null) {
                        crnOutVerifyOut = crnOutVerifyOutEnableConfig.getValue();
                    }

                    if (crnOutVerifyOut.equals("Y")) {
                        if (!staProtocol.isOutEnable()) {
                            continue;
                        }

                        if (staProtocol.getWorkNo() > 0) {
                            continue;
                        }
                    }
//                    String crnOutVerifyOut = "Y";
//                    Config crnOutVerifyOutEnableConfig = configService.selectOne(new EntityWrapper<Config>()
//                            .eq("code", "crnOutVerifyOutEnable"));
//                    if (crnOutVerifyOutEnableConfig != null) {
//                        crnOutVerifyOut = crnOutVerifyOutEnableConfig.getValue();
//                    }
//
//                    if (crnOutVerifyOut.equals("Y")) {
//                        if (!staProtocol.isOutEnable()) {
//                            continue;
//                        }
//
//                        if (staProtocol.getWorkNo() > 0) {
//                            continue;
//                        }
//                    }


                    // 命令下发区 --------------------------------------------------------------------------
@@ -1263,26 +1278,26 @@
                        break;
                    }

                    if (crnProtocol.getCrnNo() == 1) {
                        String turnCrnExecuteCurrentChannel = "Y";
                        Config turnCrnExecuteCurrentChannelConfig = configService.selectOne(new EntityWrapper<Config>()
                                .eq("code", "turnCrnExecuteCurrentChannel")
                        );
                        if (turnCrnExecuteCurrentChannelConfig != null) {
                            turnCrnExecuteCurrentChannel = turnCrnExecuteCurrentChannelConfig.getValue();
                        }

                        if (turnCrnExecuteCurrentChannel.equals("Y")) {
                            //判断堆垛机和当前任务是否处于一个巷道
                            if (Utils.getLaneByLocNo(wrkMast.getSourceLocNo()) != crnProtocol.getCrnLane()) {
                                //判断堆垛机所在巷道是否存在其他任务，如存在则优先执行
                                List<WrkMast> currentWrkMasts = wrkMastService.selectLaneWrkMast(crnProtocol.getCrnLane(), false);
                                if (!currentWrkMasts.isEmpty()) {
                                    continue;//当前堆垛机所在巷道存在任务
                                }
                            }
                        }
                    }
//                    if (crnProtocol.getCrnNo() == 1) {
//                        String turnCrnExecuteCurrentChannel = "Y";
//                        Config turnCrnExecuteCurrentChannelConfig = configService.selectOne(new EntityWrapper<Config>()
//                                .eq("code", "turnCrnExecuteCurrentChannel")
//                        );
//                        if (turnCrnExecuteCurrentChannelConfig != null) {
//                            turnCrnExecuteCurrentChannel = turnCrnExecuteCurrentChannelConfig.getValue();
//                        }
//
//                        if (turnCrnExecuteCurrentChannel.equals("Y")) {
//                            //判断堆垛机和当前任务是否处于一个巷道
//                            if (Utils.getLaneByLocNo(wrkMast.getSourceLocNo()) != crnProtocol.getCrnLane()) {
//                                //判断堆垛机所在巷道是否存在其他任务，如存在则优先执行
//                                List<WrkMast> currentWrkMasts = wrkMastService.selectLaneWrkMast(crnProtocol.getCrnLane(), false);
//                                if (!currentWrkMasts.isEmpty()) {
//                                    continue;//当前堆垛机所在巷道存在任务
//                                }
//                            }
//                        }
//                    }

                    // 双深库位且浅库位有货，则需先对浅库位进行库位移转
                    if (Utils.isDeepLoc(slaveProperties, wrkMast.getSourceLocNo())) {
@@ -2032,6 +2047,16 @@
                        continue;
                    }

                    //检测是否有入库任务
                    List<WrkMast> inWrkMasts = wrkMastService.selectList(new EntityWrapper<WrkMast>()
                            .in("io_type", 1, 53, 57)
                            .in("source_sta_no", 1002, 1007)
                    );
                    if (!inWrkMasts.isEmpty()) {
                        News.error("" + mark + " - 2" + " - 检测存在入库任务，等待入库任务执行完成再入空托，工作号={}");
                        continue;
                    }

                    int workNo = commonService.getWorkNo(3);
                    // 生成工作档
                    WrkMast wrkMast1 = new WrkMast();