From 1313906bb1eb983d3beece810035e7fc28d6a92f Mon Sep 17 00:00:00 2001
From: zhang <zc857179121@qq.com>
Date: 星期二, 20 五月 2025 16:57:11 +0800
Subject: [PATCH] 新增充电桩
---
zy-acs-manager/src/main/java/com/zy/acs/manager/core/service/AllocateService.java | 342 +++++++++++++++++++++++++++++++++++++++------------------
1 files changed, 234 insertions(+), 108 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..7204350 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,22 @@
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.manager.entity.Agv;
-import com.zy.acs.manager.manager.entity.AgvModel;
-import com.zy.acs.manager.manager.entity.Task;
+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;
-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,23 +29,48 @@
@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;
+ @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, 1));
- 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())
@@ -55,25 +81,36 @@
)) {
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;
}
+ /**
+ * 1. 鍒ゆ柇task鐨勮捣濮嬬偣鍜岀洰鐨勭偣鎵�鍦ㄧ殑宸烽亾鎵胯浇浠诲姟鏁伴噺锛�
+ * 濡傛灉鏁伴噺宸茬粡杈惧埌璐熻浇锛屽垯鍒ゆ柇璐熻浇浠诲姟鐨凙GV鏄惁杩樻湁绌鸿儗绡擄紝濡傛灉鏈夊垯浼樺厛娲惧彂缁欏畠锛�
+ * 濡傛灉娌℃湁浜嗭紝閭ｄ箞鍒欓樆濉炰换鍔★紝鐩村埌璇ュ贩閬撻噴鏀�
+ * 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());
+ 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;
}
-
Integer maxAgvCountInLane = configService.getVal("maxAgvCountInLane", Integer.class);
// checkout lane
@@ -81,110 +118,199 @@
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 full lane
+ if (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 (agvNosByDestLane.size() >= maxAgvCountInLane) {
- /**
- * 1. 鍒ゆ柇task鐨勮捣濮嬬偣鍜岀洰鐨勭偣鎵�鍦ㄧ殑宸烽亾鎵胯浇浠诲姟鏁伴噺锛�
- * 濡傛灉鏁伴噺宸茬粡杈惧埌璐熻浇锛屽垯鍒ゆ柇璐熻浇浠诲姟鐨凙GV鏄惁杩樻湁绌鸿儗绡擄紝濡傛灉鏈夊垯浼樺厛娲惧彂缁欏畠锛�
- * 濡傛灉娌℃湁浜嗭紝閭ｄ箞鍒欓樆濉炰换鍔★紝鐩村埌璇ュ贩閬撻噴鏀�
- *
- * 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));
}
- 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;
-
- List<Agv> agvList = agvService.list(new LambdaQueryWrapper<Agv>().eq(Agv::getStatus, 1));
- 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()) // 宸茬粡鏈墂aiting浠诲姟鐨勮溅涓嶈兘鍐嶅垎閰�
- .or().eq(Task::getTaskSts, TaskStsType.ASSIGN.val())
- .or().eq(Task::getTaskSts, TaskStsType.PROGRESS.val());
- })) > 0) {
- log.info(agv.getUuid() + "鍙稟GV涓嶅彲鐢紝宸茬粡瀛樺湪杩涜涓殑浠诲姟...");
- continue;
- }
- if (!agvService.judgeEnable(agv.getId(), true)) {
- log.info(agv.getUuid() + "鍙稟GV涓嶅彲鐢紝" + task.getSeqNum() + "浠诲姟鏃犳硶璁＄畻...");
- continue;
- }
-
- hit = agv;
- break;
+ public List<String> findAgvNosByLane(Lane lane) {
+ if (null == lane) {
+ return new ArrayList<>();
}
-
- return hit;
+ List<Task> taskList = taskService.findRunningTasksByLaneHash(lane.getHashCode());
+ if (Cools.isEmpty(taskList)) {
+ return new ArrayList<>();
+ }
+ return taskList.stream()
+ .map(task -> agvService.getById(task.getAgvId()).getUuid())
+ .distinct()
+ .collect(Collectors.toList());
}
- 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);
+ private List<String> validBackpackLimit(List<String> agvNoList) {
+ if (Cools.isEmpty(agvNoList)) {
+ return new ArrayList<>();
+ }
+ return agvNoList.stream().filter(agvNo -> {
+ Long agvId = agvService.getAgvId(agvNo);
+ int transportTasksCount = taskService.findTransportTasksCountByAgv(agvId);
+ AgvModel agvModel = agvModelService.getByAgvNo(agvNo);
+ return transportTasksCount < agvModel.getBackpack();
+ }).collect(Collectors.toList());
+ }
- 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()) // 宸茬粡鏈墂aiting浠诲姟鐨勮溅涓嶈兘鍐嶅垎閰�
- .or().eq(Task::getTaskSts, TaskStsType.ASSIGN.val())
- .or().eq(Task::getTaskSts, TaskStsType.PROGRESS.val());
- })) > 0) {
- log.info(agv.getUuid() + "鍙稟GV涓嶅彲鐢紝宸茬粡瀛樺湪杩涜涓殑浠诲姟...");
- return null;
- }
- if (!agvService.judgeEnable(agv.getId(), true)) {
- log.info(agv.getUuid() + "鍙稟GV涓嶅彲鐢紝" + task.getSeqNum() + "浠诲姟鏃犳硶璁＄畻...");
- return null;
+ // calculate wight = backpack + distance
+ private int calcAllocateWeight(String agvNo, Task task) {
+ int weight = 0;
+ Long agvId = agvService.getAgvId(agvNo);
+
+ // backpack
+ Integer transportTasksCount = taskService.findTransportTasksCountByAgv(agvId);
+ if (!Cools.isEmpty(transportTasksCount)) {
+ weight = weight + transportTasksCount * 100000;
}
- return agv;
+ // distance
+ // from
+ AgvDetail agvDetail = agvDetailService.selectByAgvId(agvId);
+ Code agvCurrCode = codeService.getCacheById(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.getCacheById(oriLoc.getCode());
+ break;
+ case STA_TO_LOC:
+ case STA_TO_STA:
+ Sta oriSta = staService.getById(task.getOriSta());
+ firstCode = codeService.getCacheById(oriSta.getCode());
+ break;
+ case TO_CHARGE:
+ case TO_STANDBY:
+ case MOVE:
+ firstCode = codeService.getCacheById(task.getDestCode());
+ break;
+ default:
+ firstCode = codeService.getCacheById(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 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;
+ }
+
+
+ // The Permutations and combinations for task
+
+ 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);
+ }
+
+ } 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);
+ }
+ }
+ }
+
+ theLastOne = list.get(list.size() - 1);
+ return theLastOne.get(theLastOne.size() - 1).getXy();
}
}
--
Gitblit v1.9.1