#

luxiaotao1123

2024-11-04 7f70cb15d035f0c233b9e62b9e43aa985317c908

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

@@ -18,6 +18,7 @@
import com.zy.acs.common.utils.Utils;
import com.zy.acs.manager.common.domain.TaskDto;
import com.zy.acs.manager.common.exception.BusinessException;
import com.zy.acs.manager.common.utils.CommonUtil;
import com.zy.acs.manager.core.domain.AgvBackpackDto;
import com.zy.acs.manager.core.domain.TaskPosDto;
import com.zy.acs.manager.core.service.astart.MapDataDispatcher;
@@ -67,6 +68,8 @@
    @Autowired
    private ValidService validService;
    @Autowired
    private AllocateService allocateService;
    @Autowired
    private CodeService codeService;
    @Autowired
    private MapService mapService;
@@ -88,8 +91,7 @@
    private TrafficService trafficService;
    @Autowired
    private AgvModelService agvModelService;
    @Autowired
    private MissionAssignService missionAssignService;


    @SuppressWarnings("all")
    @Transactional
@@ -108,7 +110,7 @@
        taskDtoList.sort((o1, o2) -> o2.getPriority() - o1.getPriority());

        // 校验
        List<Task> taskList = validService.validBusDto(taskDtoList);
        List<Task> taskList = validService.validTaskDtoList(taskDtoList);

        // 保存总线
        Date now = new Date();
@@ -194,7 +196,7 @@
     * 任务分配给车辆 ( 车辆此时是空闲且静止的 )
     */
    @Transactional
    public synchronized void infuseAgvForTask(Bus bus) {
    public synchronized void allocateTask(Bus bus) {
        try {
            Date now = new Date();
            List<Task> taskList = taskService.list(new LambdaQueryWrapper<Task>()
@@ -212,8 +214,9 @@
                return;
            }

            List<Long> taskIds = taskList.stream().map(Task::getId).distinct().collect(Collectors.toList());
            for (Task task : taskList) {
                Agv agv = missionAssignService.execute(task);
                Agv agv = allocateService.execute(task);
                if (null == agv) {
                    log.warn("Task[{}] has an issue， because it failed to checkout agv which is idle...", task.getSeqNum());
                    continue;
@@ -230,31 +233,31 @@

            // ------------------------------------------

            List<Long> taskIds = taskList.stream().map(Task::getId).distinct().collect(Collectors.toList());

            Map<String, List<Long>> taskAllot = new HashMap<>();
            for (Task task : taskList) {
                Agv agv = missionAssignService.execute(task, taskAllot, taskIds);
                if (null == agv) {
                    log.warn("Task[{}] has an issue， because it failed to checkout agv which is idle...", task.getSeqNum());
                    continue;
                }


                task.setAgvId(agv.getId());
                task.setTaskSts(TaskStsType.WAITING.val());
                task.setIoTime(now);
                task.setUpdateTime(now);
                if (!taskService.updateById(task)) {
                    throw new BusinessException("seqNum: " + task.getSeqNum() + " failed to update");
                }

                if (taskAllot.containsKey(agv.getUuid())) {
                    taskAllot.get(agv.getUuid()).add(task.getId());
                } else {
                    taskAllot.put(agv.getUuid(), Utils.singletonList(task.getId()));
                }
            }
//
//            Map<String, List<Long>> taskAllot = new HashMap<>();
//            for (Task task : taskList) {
//                Agv agv = missionAssignService.execute(task, taskAllot, taskIds);
//                if (null == agv) {
//                    log.warn("Task[{}] has an issue， because it failed to checkout agv which is idle...", task.getSeqNum());
//                    continue;
//                }
//
//
//                task.setAgvId(agv.getId());
//                task.setTaskSts(TaskStsType.WAITING.val());
//                task.setIoTime(now);
//                task.setUpdateTime(now);
//                if (!taskService.updateById(task)) {
//                    throw new BusinessException("seqNum: " + task.getSeqNum() + " failed to update");
//                }
//
//                if (taskAllot.containsKey(agv.getUuid())) {
//                    taskAllot.get(agv.getUuid()).add(task.getId());
//                } else {
//                    taskAllot.put(agv.getUuid(), Utils.singletonList(task.getId()));
//                }
//            }
        } catch (Exception e) {
            log.error("mainService.infuseAgvForTask", e);
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
@@ -275,7 +278,7 @@

            // valid -----------------------------------------------
            Agv agv = agvService.getById(agvId);
            if (!agvService.judgeEnable(agv.getId(), agvDetail -> agvDetail.getVol() > agv.getChargeLine())) {
            if (!agvService.judgeEnable(agv.getId(), true)) {
                throw new CoolException("AGV[" + agv.getUuid() + "]当前不可用...");
            }
            if (!Cools.isEmpty(taskService.selectInSts(agvId, TaskStsType.ASSIGN, TaskStsType.PROGRESS))) {
@@ -288,7 +291,7 @@
            taskList.sort(new Comparator<Task>() {
                @Override
                public int compare(Task o1, Task o2) {
                    return o1.getPriority() - o2.getPriority();
                    return o2.getPriority() - o1.getPriority();
                }
            });
            Integer backpack = agvService.getBackpack(agv);
@@ -296,6 +299,7 @@
                taskList = taskList.subList(0, backpack);
            }

            AgvDetail agvDetail = agvDetailService.selectByAgvId(agvId);
            List<AgvBackpackDto> backpackDtoList = new ArrayList<>();

            /**
@@ -408,6 +412,50 @@
                taskPosDtoList.sort((o1, o2) -> (int) (o1.getSecondWeight(sameGroupXy) * 100 - o2.getSecondWeight(sameGroupXy) * 100));
            }

            // re-order by agv current position
            Code currCode = codeService.getById(agvDetail.getRecentCode());
            Double[] currPosition = new Double[] {currCode.getX(), currCode.getY()};

            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);
                    }
                }
            }

            // generate travel
            Travel travel = new Travel();
            travel.setUuid(String.valueOf(snowflakeIdWorker.nextId()).substring(3));
@@ -497,15 +545,13 @@
            switch (taskType) {
                case TO_CHARGE:
                case TO_STANDBY:
                    List<FuncSta> funcStaList = funcStaService.list(new LambdaQueryWrapper<FuncSta>()
                                    .eq(FuncSta::getType, FuncStaType.query(taskType).toString())
                                    .eq(FuncSta::getAgvId, agv.getId())
                                    .eq(FuncSta::getState, FuncStaStateType.IDLE.toString())
                                    .eq(FuncSta::getStatus, StatusType.ENABLE.val)
                    );
                    if (!Cools.isEmpty(funcStaList)) {
                        FuncSta funcSta = funcStaList.get(0);
                    List<FuncSta> idleFunStaList = funcStaService.findInIdleStatus(FuncStaType.query(taskType), agv.getId());
                    if (!Cools.isEmpty(idleFunStaList)) {
                        FuncSta funcSta = funcStaService.checkoutClosestFunSta(agvDetail.getRecentCode(), idleFunStaList);
                        endCode = codeService.getById(funcSta.getCode());
                    }
                    if (null == endCode) {
                        log.warn("AGV[{}] failed to search destination，there hadn't any idle funSta，TaskTypeType：{}", agv.getUuid(), taskType.toString());
                    }
                    break;
                case MOVE:
@@ -516,7 +562,6 @@
            }

            if (null == endCode) {
                log.error("{}号车辆建立功能任务失败，无法检索到目标定位，TaskTypeType：{}", agv.getUuid(), taskType.toString());
                return false;
            }

@@ -533,7 +578,7 @@
            task.setIoTime(now);
            task.setStartTime(now);
            if (!taskService.save(task)) {
                throw new BusinessException(task.getSeqNum() + "任务保存失败");
                throw new BusinessException(task.getSeqNum() + " failed to save");
            }

            // generate travel
@@ -545,7 +590,7 @@
            travel.setTaskIds(JSON.toJSONString(Collections.singletonList(task.getId())));
            travel.setState(TravelStateType.RUNNING.toString());
            if (!travelService.save(travel)) {
                throw new BusinessException("任务组保存失败");
                throw new BusinessException("travel failed to save");
            }

            // generate segment
@@ -584,7 +629,7 @@
                    next.setState(SegmentStateType.WAITING.toString());
                }
                if (!segmentService.save(next)) {
                    throw new BusinessException("任务组保存失败");
                    throw new BusinessException("segment failed to save");
                }
            }

@@ -596,7 +641,7 @@
                    destFuncSta.setState(FuncStaStateType.OCCUPIED.toString());
                    destFuncSta.setUpdateTime(now);
                    if (!funcStaService.updateById(destFuncSta)) {
                        log.error("FuncSta [{}] 更新状态失败 ！！！", destFuncSta.getName());
                        log.error("FuncSta [{}] failed to update ！！！", destFuncSta.getName());
                    }
                    break;
                case MOVE: