From 7f70cb15d035f0c233b9e62b9e43aa985317c908 Mon Sep 17 00:00:00 2001
From: luxiaotao1123 <t1341870251@163.com>
Date: 星期一, 04 十一月 2024 10:22:45 +0800
Subject: [PATCH] #

---
 zy-acs-manager/src/main/java/com/zy/acs/manager/core/service/AllocateService.java |  171 ++++++++++++++++++++++++++++++++++++++++++++++++++-------
 1 files changed, 150 insertions(+), 21 deletions(-)

diff --git a/zy-acs-manager/src/main/java/com/zy/acs/manager/core/service/AllocateService.java b/zy-acs-manager/src/main/java/com/zy/acs/manager/core/service/AllocateService.java
index 5e7cbd4..f63a66e 100644
--- a/zy-acs-manager/src/main/java/com/zy/acs/manager/core/service/AllocateService.java
+++ b/zy-acs-manager/src/main/java/com/zy/acs/manager/core/service/AllocateService.java
@@ -2,21 +2,21 @@
 
 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;
 import org.springframework.stereotype.Service;
 
 import java.util.*;
+import java.util.stream.Collectors;
 
 /**
  * Created by vincent on 8/12/2024
@@ -28,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;
 
@@ -41,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) {
 
@@ -67,12 +75,22 @@
         return result;
     }
 
+    /**
+     * 1.   鍒ゆ柇task鐨勮捣濮嬬偣鍜岀洰鐨勭偣鎵�鍦ㄧ殑宸烽亾鎵胯浇浠诲姟鏁伴噺锛�
+     *      濡傛灉鏁伴噺宸茬粡杈惧埌璐熻浇锛屽垯鍒ゆ柇璐熻浇浠诲姟鐨凙GV鏄惁杩樻湁绌鸿儗绡擄紝濡傛灉鏈夊垯浼樺厛娲惧彂缁欏畠锛�
+     *      濡傛灉娌℃湁浜嗭紝閭d箞鍒欓樆濉炰换鍔★紝鐩村埌璇ュ贩閬撻噴鏀�
+     * 2.   杞绌洪棽灏忚溅锛岀洰鏍囨槸璁╂瘡鍙板皬杞﹂兘鍔ㄨ捣鏉�
+     *      鍒ゆ柇閫昏緫锛氳儗绡撴暟閲忔渶灏戠殑灏忚溅杞鐨勬椂鍊欙紝浼樺厛绾ф渶楂�
+     *
+     *      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());
             return null;
         }
+        List<String> availableAgvNos = availableAgvList.stream().map(Agv::getUuid).distinct().collect(Collectors.toList());
 
         Integer maxAgvCountInLane = configService.getVal("maxAgvCountInLane", Integer.class);
 
@@ -80,26 +98,137 @@
         Lane originLane = taskService.checkoutOriginLane(task);
         Lane destinationLane = taskService.checkoutDestinationLane(task);
 
+
         // allocate about origin
-        taskService.findTasksByLaneHash(originLane.getHashCode());
+        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) {
+
+                availableAgvNosByOriLane = Cools.getIntersection(agvNosByOriLane, availableAgvNos);
+            }
+        }
+        // valid backpack limit
+        availableAgvNosByOriLane = this.validBackpackLimit(availableAgvNosByOriLane);
+
 
         // allocate about destination
-        taskService.findTasksByLaneHash(destinationLane.getHashCode());
+        List<String> availableAgvNosByDestLane = new ArrayList<>(availableAgvNos);
+        if (null != destinationLane) {
+            List<String> agvNosByDestLane = findAgvNosByLane(destinationLane);
+            if (!Cools.isEmpty(agvNosByDestLane) && agvNosByDestLane.size() >= maxAgvCountInLane) {
 
-        /**
-         * 1.   鍒ゆ柇task鐨勮捣濮嬬偣鍜岀洰鐨勭偣鎵�鍦ㄧ殑宸烽亾鎵胯浇浠诲姟鏁伴噺锛�
-         *      濡傛灉鏁伴噺宸茬粡杈惧埌璐熻浇锛屽垯鍒ゆ柇璐熻浇浠诲姟鐨凙GV鏄惁杩樻湁绌鸿儗绡擄紝濡傛灉鏈夊垯浼樺厛娲惧彂缁欏畠锛�
-         *      濡傛灉娌℃湁浜嗭紝閭d箞鍒欓樆濉炰换鍔★紝鐩村埌璇ュ贩閬撻噴鏀�
-         *
-         * 2.   杞绌洪棽灏忚溅锛岀洰鏍囨槸璁╂瘡鍙板皬杞﹂兘鍔ㄨ捣鏉�
-         *      鍒ゆ柇閫昏緫锛氳儗绡撴暟閲忔渶灏戠殑灏忚溅杞鐨勬椂鍊欙紝浼樺厛绾ф渶楂�
-         */
+                availableAgvNosByDestLane = Cools.getIntersection(agvNosByDestLane, availableAgvNos);
+            }
+        }
+        availableAgvNosByDestLane = this.validBackpackLimit(availableAgvNosByDestLane);
+
+        // valid
+        if (Cools.isEmpty(availableAgvNosByOriLane)) {
+            log.warn("No available agv to assign the task origin[{}]", task.getSeqNum());
+            return null;
+        }
+        if (Cools.isEmpty(availableAgvNosByDestLane)) {
+            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());
+            return null;
+        }
+
+        // choose min number of running task
+        actualAvailableAgvNos.sort(new Comparator<String>() {
+            @Override
+            public int compare(String agvNo1, String agvNo2) {
+                return calcAllocateWeight(agvNo1, task) - calcAllocateWeight(agvNo2, task);
+            }
+        });
 
 
-        task.setOriLaneHash(originLane.getHashCode());
-        task.setDestLaneHash(destinationLane.getHashCode());
+        if (null != originLane) {
+            task.setOriLaneHash(originLane.getHashCode());
+        }
+        if (null != destinationLane) {
+            task.setDestLaneHash(destinationLane.getHashCode());
+        }
 
-        return null;
+        return agvService.selectByUuid(actualAvailableAgvNos.stream().findFirst().orElse(null));
+    }
+
+    private List<String> findAgvNosByLane(Lane lane) {
+        if (null == lane) {
+            return null;
+        }
+        List<Task> taskList = taskService.findRunningTasksByLaneHash(lane.getHashCode());
+        if (Cools.isEmpty(taskList)) {
+            return null;
+        }
+        return taskList.stream().map(task -> {
+            return agvService.getById(task.getAgvId()).getUuid();
+        }).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) {
@@ -110,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());

--
Gitblit v1.9.1