agv逻辑调整

chen.llin

3 天以前 65539f6fb4d836180f784c2c4e0bc441764cd23f

 src/main/java/com/zy/asrs/task/handler/AgvHandler.java

@@ -80,7 +80,7 @@
        for (Task task : taskList) {
            // 如果任务状态已经是8（已呼叫AGV，正在搬运），则不再发送指令
            if (task.getWrkSts() != null && task.getWrkSts() == 8L) {
                log.debug("任务ID：{}状态已是8（正在搬运），跳过发送", task.getId());
                // log.debug("任务ID：{}状态已是8（正在搬运），跳过发送", task.getId());
                continue;
            }
            
@@ -90,7 +90,7 @@
                String errorMsg = allocateSiteForTask(task);
                if (errorMsg != null) {
                    // 无法分配站点，只在日志中记录，不记录到任务中（app不需要知道）
                    log.warn("任务ID：{}无法分配站点：{}", task.getId(), errorMsg);
                    // log.warn("任务ID：{}无法分配站点：{}", task.getId(), errorMsg);
                    continue;
                }
                // 检查是否成功分配了站点（如果返回null且staNo仍为空，说明所有站点都在搬运，等待下次再试）
@@ -99,7 +99,7 @@
                    // 所有站点都在搬运，暂不分配，等待下次定时任务再尝试
                    continue;
                }
                log.info("任务ID：{}已分配站点：{}", task.getId(), staNo);
                // log.info("任务ID：{}已分配站点：{}", task.getId(), staNo);
            }
            
            // 检查目标站点是否有效（不为0且存在）
@@ -108,18 +108,18 @@
                    Integer siteNo = Integer.parseInt(staNo);
                    // 检查站点是否为0（无效站点），如果是0则不发送，但不清空站点
                    if (siteNo == null || siteNo == 0) {
                        log.warn("任务ID：{}的目标站点{}无效（为0），跳过发送，保留站点分配", task.getId(), staNo);
                        // log.warn("任务ID：{}的目标站点{}无效（为0），跳过发送，保留站点分配", task.getId(), staNo);
                        continue;
                    }
                    List<BasDevp> basDevpList = basDevpMapper.selectList(new EntityWrapper<BasDevp>().eq("dev_no", siteNo));
                    if (basDevpList == null || basDevpList.isEmpty()) {
                        // 站点不存在，跳过发送，不清空站点
                        log.warn("任务ID：{}的目标站点{}不存在，跳过发送，保留站点分配", task.getId(), staNo);
                        // log.warn("任务ID：{}的目标站点{}不存在，跳过发送，保留站点分配", task.getId(), staNo);
                        continue;
                    }
                } catch (NumberFormatException e) {
                    // 站点格式错误，跳过发送，不清空站点
                    log.warn("任务ID：{}的目标站点{}格式错误，跳过发送，保留站点分配", task.getId(), staNo);
                    // log.warn("任务ID：{}的目标站点{}格式错误，跳过发送，保留站点分配", task.getId(), staNo);
                    continue;
                }
            } else {
@@ -155,8 +155,8 @@
                );
                
                if (!transportingTasks.isEmpty()) {
                    log.info("站点{}有{}个正在搬运的{}AGV任务，跳过当前任务ID：{}", 
                            staNo, transportingTasks.size(), taskType, task.getId());
                    // log.info("站点{}有{}个正在搬运的{}AGV任务，跳过当前任务ID：{}", 
                    //         staNo, transportingTasks.size(), taskType, task.getId());
                    continue;
                }
            }
@@ -193,8 +193,8 @@
            
            // 如果重试次数已达到最大值，跳过本次发送
            if (retryEnabled && currentRetryCount >= maxRetryCount) {
                log.warn("{}呼叫agv搬运 - 任务ID：{}已达到最大重试次数（{}），停止重试", 
                        namespace, task.getId(), maxRetryCount);
                // log.warn("{}呼叫agv搬运 - 任务ID：{}已达到最大重试次数（{}），停止重试", 
                //         namespace, task.getId(), maxRetryCount);
                // 记录最终失败信息
                task.setErrorTime(new Date());
                task.setErrorMemo(String.format("AGV呼叫失败，已达到最大重试次数（%d次）", maxRetryCount));
@@ -203,12 +203,12 @@
            }
            
            // 打印请求信息（包含重试次数）
            if (currentRetryCount > 0) {
                log.info("{}呼叫agv搬运（第{}次重试） - 请求地址：{}", namespace, currentRetryCount + 1, url);
            } else {
                log.info("{}呼叫agv搬运 - 请求地址：{}", namespace, url);
            }
            log.info("{}呼叫agv搬运 - 请求参数：{}", namespace, body);
            // if (currentRetryCount > 0) {
            //     log.info("{}呼叫agv搬运（第{}次重试） - 请求地址：{}", namespace, currentRetryCount + 1, url);
            // } else {
            //     log.info("{}呼叫agv搬运 - 请求地址：{}", namespace, url);
            // }
            // log.info("{}呼叫agv搬运 - 请求参数：{}", namespace, body);
            
            try {
                // 使用仙工M4接口
@@ -219,12 +219,12 @@
                        .build()
                        .doPost();
                // 打印返回参数
                log.info("{}呼叫agv搬运 - 返回参数：{}", namespace, response);
                // log.info("{}呼叫agv搬运 - 返回参数：{}", namespace, response);
                
                // 检查响应是否为空
                if (response == null || response.trim().isEmpty()) {
                    String errorMsg = "AGV接口返回为空";
                    log.error("{}呼叫agv搬运失败 - 任务ID：{}，{}", namespace, task.getId(), errorMsg);
                    // log.error("{}呼叫agv搬运失败 - 任务ID：{}，{}", namespace, task.getId(), errorMsg);
                    handleCallFailure(task, namespace, errorMsg, retryEnabled, maxRetryCount, currentRetryCount);
                    continue;
                }
@@ -232,7 +232,7 @@
                JSONObject jsonObject = JSON.parseObject(response);
                if (jsonObject == null) {
                    String errorMsg = "响应JSON解析失败，响应内容：" + response;
                    log.error("{}呼叫agv搬运失败 - 任务ID：{}，{}", namespace, task.getId(), errorMsg);
                    // log.error("{}呼叫agv搬运失败 - 任务ID：{}，{}", namespace, task.getId(), errorMsg);
                    handleCallFailure(task, namespace, errorMsg, retryEnabled, maxRetryCount, currentRetryCount);
                    continue;
                }
@@ -246,17 +246,17 @@
                    task.setErrorTime(null);
                    task.setErrorMemo(null);
                    taskService.updateById(task);
                    log.info("{}呼叫agv搬运成功 - 任务ID：{}", namespace, task.getId());
                    // log.info("{}呼叫agv搬运成功 - 任务ID：{}", namespace, task.getId());
                } else {
                    String message = jsonObject.getString("message");
                    String errorMsg = String.format("错误码：%s，错误信息：%s", code, message);
                    log.error("{}呼叫agv搬运失败 - 任务ID：{}，{}", namespace, task.getId(), errorMsg);
                    // log.error("{}呼叫agv搬运失败 - 任务ID：{}，{}", namespace, task.getId(), errorMsg);
                    handleCallFailure(task, namespace, errorMsg, retryEnabled, maxRetryCount, currentRetryCount);
                }
            } catch (Exception e) {
                String errorMsg = "异常信息：" + e.getMessage();
                log.error("{}呼叫agv搬运异常 - 任务ID：{}，请求地址：{}，请求参数：{}，{}", 
                        namespace, task.getId(), url, body, errorMsg, e);
                // log.error("{}呼叫agv搬运异常 - 任务ID：{}，请求地址：{}，请求参数：{}，{}", 
                //         namespace, task.getId(), url, body, errorMsg, e);
                handleCallFailure(task, namespace, errorMsg, retryEnabled, maxRetryCount, currentRetryCount);
            } finally {
                try {
@@ -271,7 +271,7 @@
                            success
                    );
                } catch (Exception e) {
                    log.error(namespace + "呼叫agv保存接口日志异常:", e);
                    // log.error(namespace + "呼叫agv保存接口日志异常:", e);
                }
            }
        }
@@ -295,8 +295,8 @@
            task.setErrorTime(new Date());
            task.setErrorMemo(String.format("AGV呼叫失败（第%d次重试）：%s", newRetryCount, errorMsg));
            taskService.updateById(task);
            log.info("{}呼叫agv搬运失败 - 任务ID：{}，已重试{}次，将在下次定时任务时继续重试（最多{}次）", 
                    namespace, task.getId(), newRetryCount, maxRetryCount);
            // log.info("{}呼叫agv搬运失败 - 任务ID：{}，已重试{}次，将在下次定时任务时继续重试（最多{}次）", 
            //         namespace, task.getId(), newRetryCount, maxRetryCount);
        } else {
            // 不启用重试或已达到最大重试次数，停止重试
            task.setErrorTime(new Date());
@@ -306,8 +306,8 @@
                task.setErrorMemo(String.format("AGV呼叫失败（重试未启用）：%s", errorMsg));
            }
            taskService.updateById(task);
            log.warn("{}呼叫agv搬运失败 - 任务ID：{}，停止重试。错误信息：{}", 
                    namespace, task.getId(), errorMsg);
            // log.warn("{}呼叫agv搬运失败 - 任务ID：{}，停止重试。错误信息：{}", 
            //         namespace, task.getId(), errorMsg);
        }
    }

@@ -390,7 +390,7 @@
            fromBin = task.getSourceStaNo();
        }
        if (fromBin == null || fromBin.isEmpty() || "0".equals(fromBin)) {
            log.warn("任务{}的源库位和源站点都为空，使用默认值", task.getId());
            // log.warn("任务{}的源库位和源站点都为空，使用默认值", task.getId());
            fromBin = "0";
        }
        object.put("fromBin", fromBin);
@@ -449,12 +449,12 @@
            // 默认使用东侧
            targetStations = agvProperties.getEastStations();
            groupKey = "east";
            log.warn("任务ID：{}的机器人组{}未识别，使用默认东侧站点", task.getId(), robotGroup);
            // log.warn("任务ID：{}的机器人组{}未识别，使用默认东侧站点", task.getId(), robotGroup);
        }
        
        if (targetStations.isEmpty()) {
            String errorMsg = "没有可用的目标站点配置";
            log.warn("任务ID：{}", errorMsg, task.getId());
            // log.warn("任务ID：{}", errorMsg, task.getId());
            return errorMsg;
        }
        
@@ -476,7 +476,7 @@
        
        if (sites.isEmpty()) {
            String errorMsg = "没有能入站点";
            log.warn("任务ID：{}", errorMsg, task.getId());
            // log.warn("任务ID：{}", errorMsg, task.getId());
            return errorMsg;
        }
        
@@ -492,7 +492,7 @@
        
        if (devListWithConfig.isEmpty()) {
            // 站点配置不允许入库（canining != "Y"），暂不分配，等待配置开通（只在定时任务中记录日志）
            log.warn("任务ID：{}没有可入站点（站点未开通可入允许：canining='Y'），暂不分配站点，等待配置开通", task.getId());
            // log.warn("任务ID：{}没有可入站点（站点未开通可入允许：canining='Y'），暂不分配站点，等待配置开通", task.getId());
            return null; // 返回null，表示暂不分配，等待配置开通
        }
        
@@ -503,7 +503,7 @@
        List<Integer> canInSites = basDevpMapper.getCanInSites(configuredSites);
        if (canInSites.isEmpty()) {
            // 所有已配置可入的站点都有出库任务，暂不分配，等待下次定时任务再尝试（只在定时任务中记录日志）
            log.warn("任务ID：{}没有可入站点（请等待出库完成），暂不分配站点，等待下次定时任务再尝试", task.getId());
            // log.warn("任务ID：{}没有可入站点（请等待出库完成），暂不分配站点，等待下次定时任务再尝试", task.getId());
            return null; // 返回null，表示暂不分配，等待下次定时任务再尝试
        }
        
@@ -520,7 +520,7 @@
        if (devList.isEmpty()) {
            // 理论上不应该到这里，因为前面已经检查过了，但为了安全起见还是保留
            String errorMsg = "没有可入站点（in_enable='Y'且canining='Y'）";
            log.warn("任务ID：{}", errorMsg, task.getId());
            // log.warn("任务ID：{}", errorMsg, task.getId());
            return errorMsg;
        }
        
@@ -599,15 +599,15 @@
                isTransporting = !transportingTasks.isEmpty();
                
                if (isTransporting) {
                    log.debug("站点{}有{}个正在搬运的{}AGV任务，检查下一个站点", 
                        staNo, transportingTasks.size(), taskTypeName);
                    // log.debug("站点{}有{}个正在搬运的{}AGV任务，检查下一个站点", 
                    //     staNo, transportingTasks.size(), taskTypeName);
                    continue; // 该站点正在搬运，检查下一个站点
                }
            }
            
            // 找到第一个空闲站点，分配
            selectedSite = dev;
            log.info("任务ID：{}按规则应分配到站点{}，该站点空闲，分配成功", task.getId(), staNo);
            // log.info("任务ID：{}按规则应分配到站点{}，该站点空闲，分配成功", task.getId(), staNo);
            break;
        }
        
@@ -623,7 +623,7 @@
        // 检查站点是否有效（不能为0或null）
        if (endSite == null || endSite == 0) {
            String errorMsg = String.format("分配的站点无效（dev_no=%s）", endSite);
            log.error("任务ID：{}，{}", task.getId(), errorMsg);
            // log.error("任务ID：{}，{}", task.getId(), errorMsg);
            return errorMsg;
        }
        
@@ -634,7 +634,7 @@
        task.setStaNo(String.valueOf(endSite));
        taskService.updateById(task);
        
        log.info("任务ID：{}已分配站点：{}", task.getId(), endSite);
        // log.info("任务ID：{}已分配站点：{}", task.getId(), endSite);
        return null; // 分配成功，返回null
    }