From 7ac5a3f2bcbb0d0e13dc87cd969c8fb1fd99b488 Mon Sep 17 00:00:00 2001
From: vincentlu <t1341870251@gmail.com>
Date: 星期日, 04 一月 2026 10:38:42 +0800
Subject: [PATCH] #
---
zy-acs-manager/src/main/java/com/zy/acs/manager/core/service/AllocateService.java | 340 +++++++++++++++++++++++++++++++++++++++++++++++---------
1 files changed, 282 insertions(+), 58 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 1c7f530..b3f75fe 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
@@ -3,17 +3,18 @@
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.domain.AgvCntDto;
+import com.zy.acs.manager.core.domain.FilterLaneDto;
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;
-import com.zy.acs.manager.manager.enums.TaskTypeType;
+import com.zy.acs.manager.manager.enums.*;
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 org.springframework.transaction.annotation.Transactional;
import java.util.*;
import java.util.stream.Collectors;
@@ -24,6 +25,8 @@
@Slf4j
@Service
public class AllocateService {
+
+ public static final Integer OUTBOUND_TASKS_ALLOCATE_LIMIT = 5;
@Autowired
private AgvService agvService;
@@ -43,36 +46,103 @@
private LocService locService;
@Autowired
private LaneService laneService;
+ @Autowired
+ private AgvAreaDispatcher agvAreaDispatcher;
+ @Autowired
+ private SegmentService segmentService;
/**
* 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);
+ private List<String> getAvailableAgvNos(List<Long> agvIds, boolean hasRunning) {
+ List<Agv> agvList = Cools.isEmpty(agvIds)
+ ? agvService.list(new LambdaQueryWrapper<Agv>().eq(Agv::getStatus, StatusType.ENABLE.val))
+ : agvIds.stream().map(agvService::getById).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())
- .and(i ->
- i.eq(Task::getTaskSts, TaskStsType.ASSIGN.val())
- .or().eq(Task::getTaskSts, TaskStsType.PROGRESS.val())
- )
- )) {
- continue;
+ if (!hasRunning) {
+ // 1. without running tasks
+ if (0 < taskService.count(new LambdaQueryWrapper<Task>()
+ .eq(Task::getAgvId, agv.getId())
+ .and(i -> i
+ .eq(Task::getTaskSts, TaskStsType.ASSIGN.val())
+ .or()
+ .eq(Task::getTaskSts, TaskStsType.PROGRESS.val())
+ )
+ )) {
+ 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;
+ }
+
+ @Transactional(rollbackFor = Exception.class)
+ public synchronized String execute(Task task, AllocateSupport inbound, AllocateSupport normal) {
+ // inbound roller station
+ Sta rollerOriSta = getInboundRollerSta(task);
+ String inboundAgv = tryAllocateForRoller(task, rollerOriSta, true);
+ if (!Cools.isEmpty(inboundAgv)) {
+ inbound.success(task, inboundAgv, rollerOriSta);
+ return inboundAgv;
+ }
+
+ // outbound roller station
+ Sta rollerDestSta = getOutboundRollerSta(task);
+ String outboundAgv = tryAllocateForRoller(task, rollerDestSta, false);
+ if (!Cools.isEmpty(outboundAgv)) {
+ normal.success(task, outboundAgv, rollerDestSta);
+ return outboundAgv;
+ }
+
+ String normalAgv = this.normalExecute(task);
+ if (!Cools.isEmpty(normalAgv)) {
+ normal.success(task, normalAgv, null);
+ return normalAgv;
+ }
+
+ return null;
+ }
+
+ private String tryAllocateForRoller(Task task, Sta rollerSta, boolean inbound) {
+ if (rollerSta == null) {
+ return null;
+ }
+
+ List<String> availableAgvNos = this.getAvailableAgvNos(agvAreaDispatcher.getAgvNosByTask(task), true);
+ FilterLaneDto filterLaneDto = this.filterThroughLane(task, availableAgvNos);
+ if (filterLaneDto == null) {
+ return null;
+ }
+
+ String agvNo = inbound
+ ? this.checkoutAgvForInboundRoller(task, rollerSta, filterLaneDto.getActualAvailableAgvNos())
+ : this.checkoutAgvForOutboundRoller(task, rollerSta, filterLaneDto.getActualAvailableAgvNos());
+ if (Cools.isEmpty(agvNo)) {
+ return null;
+ }
+
+ // record lane hash for later dispatch/traffic-control logic
+ if (filterLaneDto.getOriginLane() != null) {
+ task.setOriLaneHash(filterLaneDto.getOriginLane().getHashCode());
+ }
+ if (filterLaneDto.getDestinationLane() != null) {
+ task.setDestLaneHash(filterLaneDto.getDestinationLane().getHashCode());
+ }
+
+ return agvNo;
}
/**
@@ -84,20 +154,142 @@
*
* 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());
+ public synchronized String normalExecute(Task task) {
+ List<String> availableAgvNos = this.getAvailableAgvNos(agvAreaDispatcher.getAgvNosByTask(task), false);
+// List<String> availableAgvNos = this.getAvailableAgvNos(null);
+ 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());
+
+ // calc lane
+ FilterLaneDto filterLaneDto = this.filterThroughLane(task, availableAgvNos);
+ if (null == filterLaneDto) {
+ return null;
+ }
+ Lane originLane = filterLaneDto.getOriginLane();
+ Lane destinationLane = filterLaneDto.getDestinationLane();
+ List<String> actualAvailableAgvNos = filterLaneDto.getActualAvailableAgvNos();
+ if (Cools.isEmpty(actualAvailableAgvNos)) {
+ return null;
+ }
+
+ // choose min number of running task
+ actualAvailableAgvNos.sort(Comparator.comparingInt(agvNo -> calcAllocateWeight(agvNo, task)));
+
+ if (null != originLane) {
+ task.setOriLaneHash(originLane.getHashCode());
+ }
+ if (null != destinationLane) {
+ task.setDestLaneHash(destinationLane.getHashCode());
+ }
+
+ return actualAvailableAgvNos.get(0);
+ }
+
+ private String checkoutAgvForInboundRoller(Task task, Sta sta, List<String> availableAgvNos) {
+ if (Cools.isEmpty(availableAgvNos, task, sta)) {
+ return null;
+ }
+
+ for (String agvNo : availableAgvNos) {
+ Long agvId = agvService.getAgvId(agvNo);
+ Code currentCode = agvDetailService.getCurrentCode(agvId);
+ if (null == currentCode) {
+ continue;
+ }
+
+ // only checkout the agv which at sta code position
+ if (!sta.getCode().equals(currentCode.getId())) {
+ continue;
+ }
+
+ // has running task and within oriSta
+// int taskCnt = taskService.count(new LambdaQueryWrapper<Task>()
+// .eq(Task::getAgvId, agvId)
+// .eq(Task::getOriSta, sta.getId())
+// .and(wrapper -> wrapper
+// .eq(Task::getTaskSts, TaskStsType.ASSIGN.val())
+// .or()
+// .eq(Task::getTaskSts, TaskStsType.PROGRESS.val())
+// )
+// );
+// if (taskCnt == 0) {
+// continue;
+// }
+ // in TransferStationHandler.hasDelayAtSta
+ Segment currSeg = segmentService.getRollerWaiting(agvId, sta.getCode(), TaskPosDto.PosType.ORI_STA);
+ if (null == currSeg) {
+ continue;
+ }
+
+ // has enough backpack space to load
+ Integer backpack = agvService.getBackpack(agvId);
+ List<Integer> usedBackpacks = segmentService.selectUsedBackpacks(null, agvId);
+ if (usedBackpacks.size() >= backpack) {
+ continue;
+ }
+
+ return agvNo;
+ }
+
+ return null;
+ }
+
+ private String checkoutAgvForOutboundRoller(Task task, Sta sta, List<String> availableAgvNos) {
+ if (Cools.isEmpty(availableAgvNos, task, sta)) {
+ return null;
+ }
+
+ List<Task> taskList = taskService.list(new LambdaQueryWrapper<Task>()
+ .eq(Task::getDestSta, sta.getId())
+ .eq(Task::getTaskSts, TaskStsType.WAITING.val())
+ .isNotNull(Task::getAgvId)
+ );
+ if (Cools.isEmpty(taskList)) {
+ return null;
+ }
+
+ List<AgvCntDto> cntDtoList = new ArrayList<>();
+ for (Task t : taskList) {
+ AgvCntDto cntDto = new AgvCntDto(t.getAgvId());
+ if (AgvCntDto.has(cntDtoList, cntDto)) {
+ AgvCntDto dto = AgvCntDto.find(cntDtoList, cntDto);
+ assert null != dto;
+ dto.setCount(dto.getCount() + 1);
+ } else {
+ cntDtoList.add(cntDto);
+ }
+ }
+
+ cntDtoList.sort(new Comparator<AgvCntDto>() {
+ @Override
+ public int compare(AgvCntDto o1, AgvCntDto o2) {
+ return o1.getCount() - o2.getCount();
+ }
+ });
+
+ for (AgvCntDto cntDto : cntDtoList) {
+
+ if (cntDto.getAgvId() >= OUTBOUND_TASKS_ALLOCATE_LIMIT) {
+ continue;
+ }
+ return agvService.getAgvNo(cntDto.getAgvId());
+ }
+
+ return null;
+ }
+
+ public FilterLaneDto filterThroughLane(Task task, List<String> availableAgvNos) {
+ if (Cools.isEmpty(availableAgvNos, task)) {
+ return null;
+ }
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);
@@ -139,23 +331,7 @@
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);
- }
- });
-
-
- if (null != originLane) {
- task.setOriLaneHash(originLane.getHashCode());
- }
- if (null != destinationLane) {
- task.setDestLaneHash(destinationLane.getHashCode());
- }
-
- return agvService.selectByUuid(actualAvailableAgvNos.stream().findFirst().orElse(null));
+ return new FilterLaneDto(originLane, destinationLane, actualAvailableAgvNos);
}
public List<String> findAgvNosByLane(Lane lane) {
@@ -177,28 +353,28 @@
return new ArrayList<>();
}
return agvNoList.stream().filter(agvNo -> {
- Agv agv = agvService.selectByUuid(agvNo);
- AgvModel agvModel = agvModelService.getById(agv.getAgvModel());
- List<Task> transportTasks = taskService.findTransportTasksByAgv(agv.getId());
- return transportTasks.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> transportTasks = taskService.findTransportTasksByAgv(agv.getId());
- 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(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;
@@ -207,20 +383,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 +408,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;
}
@@ -295,4 +471,52 @@
return theLastOne.get(theLastOne.size() - 1).getXy();
}
+
+
+ // about roller --------------------------------------------
+
+ private Sta getInboundRollerSta(Task task) {
+ TaskTypeType type = TaskTypeType.get(task.getTaskTypeEl());
+ switch (Objects.requireNonNull(type)) {
+ case STA_TO_LOC:
+ case STA_TO_STA:
+ Long oriStaId = task.getOriSta();
+ if (null == oriStaId) {
+ return null;
+ }
+ Sta oriSta = staService.getById(oriStaId);
+ if (oriSta == null || Cools.isEmpty(oriSta.getStaType())) {
+ return null;
+ }
+ if (StaTypeType.ROLLER.val() != oriSta.getStaType()) {
+ return null;
+ }
+ return oriSta;
+ default:
+ return null;
+ }
+ }
+
+ private Sta getOutboundRollerSta(Task task) {
+ TaskTypeType type = TaskTypeType.get(task.getTaskTypeEl());
+ switch (Objects.requireNonNull(type)) {
+ case LOC_TO_STA:
+ case STA_TO_STA:
+ Long destStaId = task.getDestSta();
+ if (null == destStaId) {
+ return null;
+ }
+ Sta destSta = staService.getById(destStaId);
+ if (destSta == null || Cools.isEmpty(destSta.getStaType())) {
+ return null;
+ }
+ if (StaTypeType.ROLLER.val() != destSta.getStaType()) {
+ return null;
+ }
+ return destSta;
+ default:
+ return null;
+ }
+ }
+
}
--
Gitblit v1.9.1