agv出库逻辑

chen.llin

2 天以前 d7020a8f1ec6f55167b4ad14941de0e28ce3d8c1

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

@@ -87,19 +87,38 @@
                log.info("任务ID：{}已分配站点：{}", task.getId(), staNo);
            }
            
            // 检查目标站点是否有未完成的AGV任务
            // 如果站点有未完成的任务，则跳过本次发送，等待下次
            if (staNo != null && !staNo.isEmpty()) {
                List<Task> unfinishedTasks = taskService.selectList(new EntityWrapper<Task>()
            // 检查目标站点是否有正在搬运的同类型AGV任务（出库和入库互不干扰）
            // 只有状态8（已呼叫AGV，正在搬运）的任务才会阻塞，状态7（待呼叫）的任务不阻塞
            // 这样可以避免所有任务都卡在呼叫状态，按id最小的优先呼叫
            if (staNo != null && !staNo.isEmpty() && task.getIoType() != null) {
                // 根据当前任务类型，只检查同类型的正在搬运任务（状态8）
                // 入库任务（ioType < 100）：只检查入库类型的正在搬运任务
                // 出库任务（ioType >= 100）：只检查出库类型的正在搬运任务
                List<Integer> ioTypes;
                String taskType;
                if (task.getIoType() < 100) {
                    // 入库任务：只检查入库类型（1, 10, 53, 57）
                    ioTypes = Arrays.asList(1, 10, 53, 57);
                    taskType = "入库";
                } else {
                    // 出库任务：只检查出库类型（101, 110, 103, 107）
                    ioTypes = Arrays.asList(101, 110, 103, 107);
                    taskType = "出库";
                }
                
                // 只检查状态为8（已呼叫AGV，正在搬运）的同类型任务
                List<Task> transportingTasks = taskService.selectList(
                    new EntityWrapper<Task>()
                        .eq("sta_no", staNo)
                        .eq("task_type", "agv")
                        .eq("wrk_sts", 8L) // 只检查正在搬运状态的任务
                        .in("io_type", ioTypes)
                        .ne("id", task.getId()) // 排除当前任务本身
                        .last("AND wrk_sts NOT IN (5, 15)") // 排除已完成状态
                );
                
                if (!unfinishedTasks.isEmpty()) {
                    log.info("站点{}有{}个未完成的AGV任务，跳过本次发送，等待任务完成。当前任务ID：{}", 
                            staNo, unfinishedTasks.size(), task.getId());
                if (!transportingTasks.isEmpty()) {
                    log.info("站点{}有{}个正在搬运的{}AGV任务，跳过本次发送，等待搬运完成。当前任务ID：{}", 
                            staNo, transportingTasks.size(), taskType, task.getId());
                    continue; // 跳过本次发送，等待下次
                }
            }
@@ -303,15 +322,65 @@
            return null;
        }
        
        // 排除有正在搬运任务的站点（状态8：已呼叫AGV，正在搬运）
        List<BasDevp> availableDevList = new ArrayList<>();
        Integer taskIoType = task.getIoType();
        
        if (taskIoType != null) {
            // 根据任务类型确定要检查的io_type列表
            List<Integer> checkIoTypes;
            String taskTypeName;
            if (taskIoType < 100) {
                // 入库任务：只检查入库类型（1, 10, 53, 57）
                checkIoTypes = Arrays.asList(1, 10, 53, 57);
                taskTypeName = "入库";
            } else {
                // 出库任务：只检查出库类型（101, 110, 103, 107）
                checkIoTypes = Arrays.asList(101, 110, 103, 107);
                taskTypeName = "出库";
            }
            
            // 检查每个站点是否有正在搬运的同类型任务
            for (BasDevp dev : devList) {
                String staNo = String.valueOf(dev.getDevNo());
                // 查询该站点是否有状态8（正在搬运）的同类型任务
                List<Task> transportingTasks = taskService.selectList(
                    new EntityWrapper<Task>()
                        .eq("sta_no", staNo)
                        .eq("task_type", "agv")
                        .eq("wrk_sts", 8L) // 只检查正在搬运状态的任务
                        .in("io_type", checkIoTypes)
                );
                
                if (transportingTasks.isEmpty()) {
                    // 该站点没有正在搬运的任务，可以分配
                    availableDevList.add(dev);
                } else {
                    log.debug("站点{}有{}个正在搬运的{}AGV任务，跳过分配", 
                        staNo, transportingTasks.size(), taskTypeName);
                }
            }
        } else {
            // 如果ioType为空，不进行过滤（保持原有逻辑）
            availableDevList = devList;
        }
        
        // 如果所有站点都在搬运，则不分配站点
        if (availableDevList.isEmpty()) {
            log.warn("任务ID：{}的所有候选站点都有正在搬运的{}任务，暂不分配站点", 
                task.getId(), taskIoType != null && taskIoType < 100 ? "入库" : "出库");
            return null;
        }
        
        // 入库任务数排序
        devList.sort(Comparator.comparing(BasDevp::getInQty));
        availableDevList.sort(Comparator.comparing(BasDevp::getInQty));
        
        // 选择站点
        BasDevp basDevp;
        int minInQty = devList.get(0).getInQty();
        int minInQty = availableDevList.get(0).getInQty();
        
        // 筛选出任务数最少的站点列表
        List<BasDevp> minTaskSites = devList.stream()
        List<BasDevp> minTaskSites = availableDevList.stream()
                .filter(dev -> dev.getInQty() == minInQty)
                .collect(Collectors.toList());