1

zhang

2025-08-28 60edff747d52eb42aadb036e3fbd580252de4c05

 zy-acs-manager/src/main/java/com/zy/acs/manager/core/service/AllocateService.java

@@ -3,6 +3,7 @@
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.zy.acs.framework.common.Cools;
import com.zy.acs.manager.common.utils.CommonUtil;
import com.zy.acs.manager.core.constant.AgvAreaDispatcher;
import com.zy.acs.manager.core.domain.Lane;
import com.zy.acs.manager.core.domain.TaskPosDto;
import com.zy.acs.manager.manager.entity.*;
@@ -43,16 +44,33 @@
    private LocService locService;
    @Autowired
    private LaneService laneService;
    @Autowired
    private AgvAreaDispatcher agvAreaDispatcher;

    /**
     * get available agv list which is idle
     */
    private List<Agv> getAvailableAgv() {
        List<Agv> result = new ArrayList<>();
        List<Agv> agvList = agvService.list(new LambdaQueryWrapper<Agv>().eq(Agv::getStatus, StatusType.ENABLE.val));
        Collections.shuffle(agvList);
        for (Agv agv : agvList) {
    private List<String> getAvailableAgvNos(List<String> agvNos) {
//        List<Agv> agvList = new ArrayList<>();
//        if (Cools.isEmpty(agvNos)) {
//            // global
//            agvList = agvService.list(new LambdaQueryWrapper<Agv>().eq(Agv::getStatus, StatusType.ENABLE.val));
//        } else {
//            // local
//            for (String agvNo : agvNos) {
//                Agv agv = agvService.selectByUuid(agvNo);
//                if (agv.getStatusBool()) {
//                    agvList.add(agv);
//                }
//            }
//        }

        List<Agv> agvList = Cools.isEmpty(agvNos)
                ? agvService.list(new LambdaQueryWrapper<Agv>().eq(Agv::getStatus, StatusType.ENABLE.val))
                : agvNos.stream().map(agvService::selectByUuid).filter(Agv::getStatusBool).collect(Collectors.toList());

        List<String> result = new ArrayList<>();
        for (Agv agv : agvList) {
            // 1. without running tasks
            if (0 < taskService.count(new LambdaQueryWrapper<Task>()
                    .eq(Task::getAgvId, agv.getId())
@@ -63,13 +81,16 @@
            )) {
                continue;
            }

            // 2. in idle status
            if (!agvService.judgeEnable(agv.getId(), true)) {
                continue;
            }

            result.add(agv);
            result.add(agv.getUuid());
        }

        if (!Cools.isEmpty(result)) {
            Collections.shuffle(result);
        }

        return result;
@@ -85,19 +106,16 @@
     *      it can break the limit of the number of agv backpack
     */
    public synchronized Agv execute(Task task) {
        List<Agv> availableAgvList = getAvailableAgv();
        if (Cools.isEmpty(availableAgvList)) {
        List<String> availableAgvNos = this.getAvailableAgvNos(agvAreaDispatcher.getAgvNosByTask(task));
        if (Cools.isEmpty(availableAgvNos)) {
//            log.warn("No available agv to assign the task[{}]", task.getSeqNum());
            return null;
        }
        List<String> availableAgvNos = availableAgvList.stream().map(Agv::getUuid).distinct().collect(Collectors.toList());

        Integer maxAgvCountInLane = configService.getVal("maxAgvCountInLane", Integer.class);

        // checkout lane
        Lane originLane = taskService.checkoutOriginLane(task);
        Lane destinationLane = taskService.checkoutDestinationLane(task);


        // allocate about origin
        List<String> availableAgvNosByOriLane = new ArrayList<>(availableAgvNos);
@@ -177,10 +195,10 @@
            return new ArrayList<>();
        }
        return agvNoList.stream().filter(agvNo -> {
            Agv agv = agvService.selectByUuid(agvNo);
            Long agvId = agvService.getAgvId(agvNo);
            int transportTasksCount = taskService.findTransportTasksCountByAgv(agvId);
            AgvModel agvModel = agvModelService.getByAgvNo(agvNo);
            List<Task> transportTasks = taskService.findTransportTasksByAgv(agv.getId());
            return transportTasks.size() < agvModel.getBackpack();
            return transportTasksCount < agvModel.getBackpack();
        }).collect(Collectors.toList());
    }

@@ -190,15 +208,15 @@
        Long agvId = agvService.getAgvId(agvNo);

        // backpack
        List<Task> transportTasks = taskService.findTransportTasksByAgv(agvId);
        if (!Cools.isEmpty(transportTasks)) {
            weight = weight + transportTasks.size() * 100000;
        Integer transportTasksCount = taskService.findTransportTasksCountByAgv(agvId);
        if (!Cools.isEmpty(transportTasksCount)) {
            weight = weight + transportTasksCount * 100000;
        }

        // distance
        // from
        AgvDetail agvDetail = agvDetailService.selectByAgvId(agvId);
        Code agvCurrCode = codeService.getById(agvDetail.getRecentCode());
        Code agvCurrCode = codeService.getCacheById(agvDetail.getRecentCode());
        Double[] fromPosition = new Double[]{agvCurrCode.getX(), agvCurrCode.getY()};
        // to
        Code firstCode = null;
@@ -207,20 +225,20 @@
            case LOC_TO_LOC:
            case LOC_TO_STA:
                Loc oriLoc = locService.getById(task.getOriLoc());
                firstCode = codeService.getById(oriLoc.getCode());
                firstCode = codeService.getCacheById(oriLoc.getCode());
                break;
            case STA_TO_LOC:
            case STA_TO_STA:
                Sta oriSta = staService.getById(task.getOriSta());
                firstCode = codeService.getById(oriSta.getCode());
                firstCode = codeService.getCacheById(oriSta.getCode());
                break;
            case TO_CHARGE:
            case TO_STANDBY:
            case MOVE:
                firstCode = codeService.getById(task.getDestCode());
                firstCode = codeService.getCacheById(task.getDestCode());
                break;
            default:
                firstCode = codeService.getById(task.getDestCode());
                firstCode = codeService.getCacheById(task.getDestCode());
                break;
        }
        assert null != firstCode;
@@ -232,13 +250,13 @@
        return -weight;
    }

    public Boolean validCapacityOfLane(Agv agv, Code code) {
    public Boolean validCapacityOfLane(String agvNo, Code code) {
        Lane lane = laneService.search(code.getData());
        if (null != lane) {
            Integer maxAgvCountInLane = configService.getVal("maxAgvCountInLane", Integer.class);

            List<String> agvNosByLane = this.findAgvNosByLane(lane);
            agvNosByLane.remove(agv.getUuid());
            agvNosByLane.remove(agvNo);
            if (agvNosByLane.size() >= maxAgvCountInLane) {
                return false;
            }