#

vincentlu

2025-05-13 ebd2f4397a92c6a5096de1b86d59154363344720

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

@@ -2,8 +2,10 @@

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.zy.acs.framework.common.Cools;
import com.zy.acs.manager.common.utils.LocUtils;
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.*;
import com.zy.acs.manager.manager.enums.StatusType;
import com.zy.acs.manager.manager.enums.TaskStsType;
@@ -42,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())
@@ -62,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;
@@ -84,25 +106,23 @@
     *      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)) {
            log.warn("No available agv to assign the task[{}]", task.getSeqNum());
        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);
        if (null != originLane) {
            List<String> agvNosByOriLane = findAgvNosByLane(originLane);    // the agv list that had tasks in this lane
            if (!Cools.isEmpty(agvNosByOriLane) && agvNosByOriLane.size() >= maxAgvCountInLane) {
            // if full lane
            if (agvNosByOriLane.size() >= maxAgvCountInLane) {

                availableAgvNosByOriLane = Cools.getIntersection(agvNosByOriLane, availableAgvNos);
            }
@@ -115,7 +135,7 @@
        List<String> availableAgvNosByDestLane = new ArrayList<>(availableAgvNos);
        if (null != destinationLane) {
            List<String> agvNosByDestLane = findAgvNosByLane(destinationLane);
            if (!Cools.isEmpty(agvNosByDestLane) && agvNosByDestLane.size() >= maxAgvCountInLane) {
            if (agvNosByDestLane.size() >= maxAgvCountInLane) {

                availableAgvNosByDestLane = Cools.getIntersection(agvNosByDestLane, availableAgvNos);
            }
@@ -131,7 +151,6 @@
            log.warn("No available agv to assign the task destination[{}]", task.getSeqNum());
            return null;
        }

        List<String> actualAvailableAgvNos = Cools.getIntersection(availableAgvNosByOriLane, availableAgvNosByDestLane);
        if (Cools.isEmpty(actualAvailableAgvNos)) {
            log.warn("No available agv to assign the task[{}]", task.getSeqNum());
@@ -157,17 +176,18 @@
        return agvService.selectByUuid(actualAvailableAgvNos.stream().findFirst().orElse(null));
    }

    private List<String> findAgvNosByLane(Lane lane) {
    public List<String> findAgvNosByLane(Lane lane) {
        if (null == lane) {
            return null;
            return new ArrayList<>();
        }
        List<Task> taskList = taskService.findRunningTasksByLaneHash(lane.getHashCode());
        if (Cools.isEmpty(taskList)) {
            return null;
            return new ArrayList<>();
        }
        return taskList.stream().map(task -> {
            return agvService.getById(task.getAgvId()).getUuid();
        }).distinct().collect(Collectors.toList());
        return taskList.stream()
                .map(task -> agvService.getById(task.getAgvId()).getUuid())
                .distinct()
                .collect(Collectors.toList());
    }

    private List<String> validBackpackLimit(List<String> agvNoList) {
@@ -175,28 +195,28 @@
            return new ArrayList<>();
        }
        return agvNoList.stream().filter(agvNo -> {
            Agv agv = agvService.selectByUuid(agvNo);
            AgvModel agvModel = agvModelService.getById(agv.getAgvModel());
            List<Task> runningTasks = taskService.findRunningTasksByAgv(agv.getId());
            return runningTasks.size() < agvModel.getBackpack();
            Long agvId = agvService.getAgvId(agvNo);
            int transportTasksCount = taskService.findTransportTasksCountByAgv(agvId);
            AgvModel agvModel = agvModelService.getByAgvNo(agvNo);
            return transportTasksCount < agvModel.getBackpack();
        }).collect(Collectors.toList());
    }

    // calculate wight = backpack + distance
    private int calcAllocateWeight(String agvNo, Task task) {
        int weight = 0;
        Agv agv = agvService.selectByUuid(agvNo);
        Long agvId = agvService.getAgvId(agvNo);

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

        // distance
        // from
        AgvDetail agvDetail = agvDetailService.selectByAgvId(agv.getId());
        Code agvCurrCode = codeService.getById(agvDetail.getRecentCode());
        AgvDetail agvDetail = agvDetailService.selectByAgvId(agvId);
        Code agvCurrCode = codeService.getCacheById(agvDetail.getRecentCode());
        Double[] fromPosition = new Double[]{agvCurrCode.getX(), agvCurrCode.getY()};
        // to
        Code firstCode = null;
@@ -205,118 +225,92 @@
            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;
        Double[] toPosition = new Double[]{firstCode.getX(), firstCode.getY()};
        // calculate distance
        weight = weight + this.calcPositionDistance(fromPosition, toPosition);
        weight = weight + CommonUtil.calcDistance(fromPosition, toPosition);

        // return opposite
        return -weight;
    }

    private int calcPositionDistance(Double[] from, Double[] to) {
        return (int) (Math.abs(to[0] - from[0]) + Math.abs(to[1] - from[1]));
    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(agvNo);
            if (agvNosByLane.size() >= maxAgvCountInLane) {
                return false;
            }
        }

        return true;
    }

    public synchronized Agv execute(Task task, Map<String, List<Long>> taskAllot, List<Long> taskIds) {
        String oriLocNo = task.getOriLoc$();
        int oriLocRow = LocUtils.getRow(oriLocNo);
        String destLocNo = task.getDestLoc$();
        int destLocRow = LocUtils.getRow(destLocNo);

        Agv hit = null;
    // The Permutations and combinations for task

        List<Agv> agvList = agvService.list(new LambdaQueryWrapper<Agv>().eq(Agv::getStatus, StatusType.ENABLE.val));
        Collections.shuffle(agvList);
        for (Agv agv : agvList) {
            AgvModel agvModel = agvModelService.getById(agv.getAgvModel());
            int allotTaskCount = 0;
            List<Long> allotTaskIds = taskAllot.get(agv.getUuid());
            if (!Cools.isEmpty(allotTaskIds)) {
                allotTaskCount = allotTaskIds.size();
            }
            if (allotTaskCount >= agvModel.getBackpack()) {
                continue;
            }
            if (taskService.count(new LambdaQueryWrapper<Task>()
                    .eq(Task::getAgvId, agv.getId())
                    .notIn(Task::getId, taskIds)
                    .and(i -> {
                        i.eq(Task::getTaskSts, TaskStsType.WAITING.val())   // 已经有waiting任务的车不能再分配
                                .or().eq(Task::getTaskSts, TaskStsType.ASSIGN.val())
                                .or().eq(Task::getTaskSts, TaskStsType.PROGRESS.val());
                    })) > 0) {
                log.info(agv.getUuid() + "号AGV不可用，已经存在进行中的任务...");
                continue;
            }
            if (!agvService.judgeEnable(agv.getId(), true)) {
                log.info(agv.getUuid() + "号AGV不可用，" + task.getSeqNum() + "任务无法计算...");
                continue;
    public Double[] pac(Double[] currPosition, List<List<TaskPosDto>> list) {
        List<TaskPosDto> theFirstOne = list.get(0);
        List<TaskPosDto> theLastOne = list.get(list.size() - 1);

        if (list.size() == 1) {
            TaskPosDto head = theFirstOne.get(0);
            TaskPosDto tail = theFirstOne.get(theFirstOne.size() - 1);

            int distanceByHead = CommonUtil.calcDistance(currPosition, head.getXy());
            int distanceByTail = CommonUtil.calcDistance(currPosition, tail.getXy());

            if (distanceByTail < distanceByHead) {
                Collections.reverse(theFirstOne);
            }

            hit = agv;
            break;
        } else {
            TaskPosDto headOfFirst = theFirstOne.get(0);
            TaskPosDto tailOfFirst = theFirstOne.get(theFirstOne.size() - 1);

            TaskPosDto headOfLast = theLastOne.get(0);
            TaskPosDto tailOfLast = theLastOne.get(theLastOne.size() - 1);

            int distanceByHeadOfFirst = CommonUtil.calcDistance(currPosition, headOfFirst.getXy());
            int distanceByTailOfFirst = CommonUtil.calcDistance(currPosition, tailOfFirst.getXy());

            int distanceByHeadOfLast = CommonUtil.calcDistance(currPosition, headOfLast.getXy());
            int distanceByTailOfLast = CommonUtil.calcDistance(currPosition, tailOfLast.getXy());

            if (Math.min(distanceByHeadOfLast, distanceByTailOfLast) < Math.min(distanceByHeadOfFirst, distanceByTailOfFirst)) {
                Collections.reverse(list);

                if (distanceByTailOfLast < distanceByHeadOfLast) {
                    Collections.reverse(theLastOne);
                }
            } else {
                if (distanceByTailOfFirst < distanceByHeadOfFirst) {
                    Collections.reverse(theFirstOne);
                }
            }
        }

        return hit;
    }

    public synchronized Agv execute1(Task task, Map<String, List<Long>> taskAllot, List<Long> taskIds) {
        String oriLocNo = task.getOriLoc$();
        int oriLocRow = LocUtils.getRow(oriLocNo);
        String destLocNo = task.getDestLoc$();
        int destLocRow = LocUtils.getRow(destLocNo);

        Agv agv = null;
        if (oriLocRow <= 2 && destLocRow <= 2) {
            agv = agvService.selectByUuid(String.valueOf(1));
        }
        if (oriLocRow > 2 && destLocRow > 2) {
            agv = agvService.selectByUuid(String.valueOf(2));
        }
        assert agv != null;
        AgvModel agvModel = agvModelService.getById(agv.getAgvModel());
        int allotTaskCount = 0;
        List<Long> allotTaskIds = taskAllot.get(agv.getUuid());
        if (!Cools.isEmpty(allotTaskIds)) {
            allotTaskCount = allotTaskIds.size();
        }
        if (allotTaskCount >= agvModel.getBackpack()) {
            return null;
        }
        if (taskService.count(new LambdaQueryWrapper<Task>()
                .eq(Task::getAgvId, agv.getId())
                .notIn(Task::getId, taskIds)
                .and(i -> {
                    i.eq(Task::getTaskSts, TaskStsType.WAITING.val())   // 已经有waiting任务的车不能再分配
                            .or().eq(Task::getTaskSts, TaskStsType.ASSIGN.val())
                            .or().eq(Task::getTaskSts, TaskStsType.PROGRESS.val());
                })) > 0) {
            log.info(agv.getUuid() + "号AGV不可用，已经存在进行中的任务...");
            return null;
        }
        if (!agvService.judgeEnable(agv.getId(), true)) {
            log.info(agv.getUuid() + "号AGV不可用，" + task.getSeqNum() + "任务无法计算...");
            return null;
        }

        return agv;
        theLastOne = list.get(list.size() - 1);
        return theLastOne.get(theLastOne.size() - 1).getXy();
    }

}