#

luxiaotao1123

2024-11-06 bb809ceda79f25ed58ef1e764ba7ffcae3254faa

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

@@ -2,15 +2,14 @@

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.common.utils.LocUtils;
import com.zy.acs.manager.core.domain.Lane;
import com.zy.acs.manager.manager.entity.Agv;
import com.zy.acs.manager.manager.entity.AgvModel;
import com.zy.acs.manager.manager.entity.Task;
import com.zy.acs.manager.manager.entity.*;
import com.zy.acs.manager.manager.enums.StatusType;
import com.zy.acs.manager.manager.enums.TaskStsType;
import com.zy.acs.manager.manager.service.AgvModelService;
import com.zy.acs.manager.manager.service.AgvService;
import com.zy.acs.manager.manager.service.TaskService;
import com.zy.acs.manager.manager.enums.TaskTypeType;
import com.zy.acs.manager.manager.service.*;
import com.zy.acs.manager.system.service.ConfigService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
@@ -29,11 +28,19 @@
    @Autowired
    private AgvService agvService;
    @Autowired
    private AgvDetailService agvDetailService;
    @Autowired
    private AgvModelService agvModelService;
    @Autowired
    private ConfigService configService;
    @Autowired
    private TaskService taskService;
    @Autowired
    private CodeService codeService;
    @Autowired
    private StaService staService;
    @Autowired
    private LocService locService;
    @Autowired
    private LaneService laneService;

@@ -42,7 +49,7 @@
     */
    private List<Agv> getAvailableAgv() {
        List<Agv> result = new ArrayList<>();
        List<Agv> agvList = agvService.list(new LambdaQueryWrapper<Agv>().eq(Agv::getStatus, 1));
        List<Agv> agvList = agvService.list(new LambdaQueryWrapper<Agv>().eq(Agv::getStatus, StatusType.ENABLE.val));
        Collections.shuffle(agvList);
        for (Agv agv : agvList) {

@@ -69,7 +76,13 @@
    }

    /**
     * it can break the limit of the number of agv backpack
     * 1.   判断task的起始点和目的点所在的巷道承载任务数量，
     *      如果数量已经达到负载，则判断负载任务的AGV是否还有空背篓，如果有则优先派发给它，
     *      如果没有了，那么则阻塞任务，直到该巷道释放
     * 2.   轮询空闲小车，目标是让每台小车都动起来
     *      判断逻辑：背篓数量最少的小车轮询的时候，优先级最高
     *
     *      it can break the limit of the number of agv backpack
     */
    public synchronized Agv execute(Task task) {
        List<Agv> availableAgvList = getAvailableAgv();
@@ -93,13 +106,10 @@
            if (!Cools.isEmpty(agvNosByOriLane) && agvNosByOriLane.size() >= maxAgvCountInLane) {

                availableAgvNosByOriLane = Cools.getIntersection(agvNosByOriLane, availableAgvNos);
                availableAgvNosByOriLane = availableAgvNosByOriLane.stream().filter(agvNo -> {
                    Agv agv = agvService.selectByUuid(agvNo);

                    return agv.getStatus() == 1;
                }).collect(Collectors.toList());
            }
        }
        // valid backpack limit
        availableAgvNosByOriLane = this.validBackpackLimit(availableAgvNosByOriLane);


        // allocate about destination
@@ -109,13 +119,9 @@
            if (!Cools.isEmpty(agvNosByDestLane) && agvNosByDestLane.size() >= maxAgvCountInLane) {

                availableAgvNosByDestLane = Cools.getIntersection(agvNosByDestLane, availableAgvNos);
                availableAgvNosByDestLane = availableAgvNosByDestLane.stream().filter(agvNo -> {
                    Agv agv = agvService.selectByUuid(agvNo);

                    return agv.getStatus() == 1;
                }).collect(Collectors.toList());
            }
        }
        availableAgvNosByDestLane = this.validBackpackLimit(availableAgvNosByDestLane);

        // valid
        if (Cools.isEmpty(availableAgvNosByOriLane)) {
@@ -133,29 +139,23 @@
            return null;
        }

        // choose min number of running task
        actualAvailableAgvNos.sort(new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return 0;
            public int compare(String agvNo1, String agvNo2) {
                return calcAllocateWeight(agvNo1, task) - calcAllocateWeight(agvNo2, task);
            }
        });

        String s = actualAvailableAgvNos.stream().findFirst().orElse(null);

        if (null != originLane) {
            task.setOriLaneHash(originLane.getHashCode());
        }
        if (null != destinationLane) {
            task.setDestLaneHash(destinationLane.getHashCode());
        }

        /**
         * 1.   判断task的起始点和目的点所在的巷道承载任务数量，
         *      如果数量已经达到负载，则判断负载任务的AGV是否还有空背篓，如果有则优先派发给它，
         *      如果没有了，那么则阻塞任务，直到该巷道释放
         *
         * 2.   轮询空闲小车，目标是让每台小车都动起来
         *      判断逻辑：背篓数量最少的小车轮询的时候，优先级最高
         */

        task.setOriLaneHash(originLane.getHashCode());
        task.setDestLaneHash(destinationLane.getHashCode());

        return null;
        return agvService.selectByUuid(actualAvailableAgvNos.stream().findFirst().orElse(null));
    }

    private List<String> findAgvNosByLane(Lane lane) {
@@ -171,6 +171,66 @@
        }).distinct().collect(Collectors.toList());
    }

    private List<String> validBackpackLimit(List<String> agvNoList) {
        if (Cools.isEmpty(agvNoList)) {
            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();
        }).collect(Collectors.toList());
    }

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

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

        // distance
        // from
        AgvDetail agvDetail = agvDetailService.selectByAgvId(agv.getId());
        Code agvCurrCode = codeService.getById(agvDetail.getRecentCode());
        Double[] fromPosition = new Double[]{agvCurrCode.getX(), agvCurrCode.getY()};
        // to
        Code firstCode = null;
        TaskTypeType typeType = TaskTypeType.get(task.getTaskTypeEl());
        switch (Objects.requireNonNull(typeType)) {
            case LOC_TO_LOC:
            case LOC_TO_STA:
                Loc oriLoc = locService.getById(task.getOriLoc());
                firstCode = codeService.getById(oriLoc.getCode());
                break;
            case STA_TO_LOC:
            case STA_TO_STA:
                Sta oriSta = staService.getById(task.getOriSta());
                firstCode = codeService.getById(oriSta.getCode());
                break;
            case TO_CHARGE:
            case TO_STANDBY:
            case MOVE:
                firstCode = codeService.getById(task.getDestCode());
                break;
            default:
                firstCode = codeService.getById(task.getDestCode());
                break;
        }
        assert null != firstCode;
        Double[] toPosition = new Double[]{firstCode.getX(), firstCode.getY()};
        // calculate distance
        weight = weight + CommonUtil.calcDistance(fromPosition, toPosition);

        // return opposite
        return -weight;
    }

    public synchronized Agv execute(Task task, Map<String, List<Long>> taskAllot, List<Long> taskIds) {
        String oriLocNo = task.getOriLoc$();
        int oriLocRow = LocUtils.getRow(oriLocNo);
@@ -179,7 +239,7 @@

        Agv hit = null;

        List<Agv> agvList = agvService.list(new LambdaQueryWrapper<Agv>().eq(Agv::getStatus, 1));
        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());