//package com.zy.acs.manager.core.service;
|
//
|
//import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
//import com.zy.acs.common.utils.GsonUtils;
|
//import com.zy.acs.common.utils.Utils;
|
//import com.zy.acs.framework.common.Cools;
|
//import com.zy.acs.framework.common.SnowflakeIdWorker;
|
//import com.zy.acs.framework.exception.CoolException;
|
//import com.zy.acs.manager.common.utils.MapDataUtils;
|
//import com.zy.acs.manager.core.constant.MapDataConstant;
|
//import com.zy.acs.manager.core.domain.BlockVehicleDto;
|
//import com.zy.acs.manager.core.domain.TaskPosDto;
|
//import com.zy.acs.manager.core.domain.type.BlockSeverityType;
|
//import com.zy.acs.manager.core.service.astart.MapDataDispatcher;
|
//import com.zy.acs.manager.core.service.astart.NavigateNode;
|
//import com.zy.acs.manager.core.service.astart.RetreatNavigateNode;
|
//import com.zy.acs.manager.core.service.astart.WaveNodeType;
|
//import com.zy.acs.manager.manager.entity.*;
|
//import com.zy.acs.manager.manager.enums.JamStateType;
|
//import com.zy.acs.manager.manager.enums.SegmentStateType;
|
//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.Component;
|
//import org.springframework.transaction.annotation.Transactional;
|
//import org.springframework.transaction.interceptor.TransactionAspectSupport;
|
//
|
//import java.util.ArrayList;
|
//import java.util.Arrays;
|
//import java.util.Date;
|
//import java.util.List;
|
//import java.util.stream.Collectors;
|
//
|
///**
|
// * Wavefront
|
// * Created by vincent on 6/25/2024
|
// */
|
//@Slf4j
|
//@Component
|
//public class TrafficService {
|
//
|
// @Autowired
|
// private AgvService agvService;
|
// @Autowired
|
// private AgvDetailService agvDetailService;
|
// @Autowired
|
// private CodeService codeService;
|
// @Autowired
|
// private TravelService travelService;
|
// @Autowired
|
// private SegmentService segmentService;
|
// @Autowired
|
// private MainLxtService mainService;
|
// @Autowired
|
// private MainLockWrapService mainLockWrapService;
|
// @Autowired
|
// private MapService mapService;
|
// @Autowired
|
// private MapDataDispatcher mapDataDispatcher;
|
// @Autowired
|
// private SnowflakeIdWorker snowflakeIdWorker;
|
// @Autowired
|
// private AgvModelService agvModelService;
|
// @Autowired
|
// private RetreatNavigateService retreatNavigateService;
|
// @Autowired
|
// private ConfigService configService;
|
// @Autowired
|
// private JamService jamService;
|
// @Autowired
|
// private AvoidWaveCalculator avoidWaveCalculator;
|
// @Autowired
|
// private TaskService taskService;
|
// @Autowired
|
// private FuncStaService funcStaService;
|
//
|
// @Transactional
|
// public synchronized void trigger(Segment segment) {
|
// try {
|
// Date now = new Date();
|
//
|
// // deprecate jam
|
// if (this.isExpiredJamByAvo(segment.getId())) {
|
// mainService.settleSegmentList(Utils.singletonList(segment), null);
|
// return;
|
// }
|
//
|
// // temporary -----------------
|
// Integer algoExtensionTime = configService.getVal("algoExtensionTime", Integer.class);
|
// if (null != algoExtensionTime && algoExtensionTime > 0) {
|
// Thread.sleep(algoExtensionTime);
|
// }
|
// // ---------------------------
|
//
|
// Travel travel = travelService.getById(segment.getTravelId());
|
// Agv agv = agvService.getById(travel.getAgvId());
|
// AgvDetail agvDetail = agvDetailService.selectByAgvId(travel.getAgvId());
|
// long endNode = segment.getEndNode();
|
//
|
// // valid ----------------------------------------------------
|
// if (!agvService.judgeEnable(agv.getId())) {
|
// return;
|
// }
|
//
|
// // resolve deadlock
|
//// if (configService.getVal("unlockSwitch", Boolean.class)) {
|
////
|
//// boolean preSegIsStandbyDeadLock = false;
|
//// Segment previousSeg = segmentService.getPreviousStepOfFinish(segment.getTravelId(), segment.getSerial(), MapDataConstant.RESOLVE_DEADLOCK);
|
//// preSegIsStandbyDeadLock = previousSeg != null;
|
//// if (preSegIsStandbyDeadLock && !jamService.isAvoidSeg(segment.getId())) {
|
//// if (0 < segmentService.count(new LambdaQueryWrapper<Segment>()
|
//// .in(Segment::getState, SegmentStateType.WAITING.toString(), SegmentStateType.RUNNING.toString())
|
//// .eq(Segment::getMemo, MapDataConstant.RESOLVE_DEADLOCK))) {
|
//// return;
|
//// }
|
//// }
|
////
|
//// Jam jam = jamService.getJam(agv.getId(), agvDetail.getRecentCode(), segment.getId());
|
//// if (!preSegIsStandbyDeadLock && (null != jam && null != jam.getDuration() && jam.getDuration() > (BlockSeverityType.SEVERE.duration - MapDataConstant.MAX_JAM_TIMEOUT)
|
//// || DateUtils.diffToMilliseconds(segment.getUpdateTime(), now) > (BlockSeverityType.SEVERE.duration - MapDataConstant.MAX_JAM_TIMEOUT))
|
//// && (Cools.isEmpty(segment.getMemo()) || !segment.getMemo().equals(MapDataConstant.RESOLVE_DEADLOCK))) {
|
////
|
//// Task task = taskService.getById(segment.getTaskId());
|
//// if (task.getTaskSts().equals(TaskStsType.PROGRESS.val())
|
//// && DateUtils.diffToMilliseconds(task.getUpdateTime(), now) > MapDataConstant.DEADLOCK_TASK_TIMEOUT) {
|
////
|
//// Code endCode = null;
|
//// List<FuncSta> idleFunStaList = funcStaService.findInIdleStatus(FuncStaType.STANDBY, segment.getAgvId());
|
//// if (!Cools.isEmpty(idleFunStaList)) {
|
//// idleFunStaList = idleFunStaList.stream().filter(funcSta -> {
|
//// return 0 == segmentService.count(new LambdaQueryWrapper<Segment>()
|
//// .eq(Segment::getEndNode, funcSta.getCode())
|
//// .in(Segment::getState, SegmentStateType.WAITING.toString(), SegmentStateType.RUNNING.toString())
|
//// .eq(Segment::getMemo, MapDataConstant.RESOLVE_DEADLOCK)
|
//// );
|
//// }).collect(Collectors.toList());
|
//// FuncSta funcSta = funcStaService.checkoutFurthestFunSta(agvDetailService.getCurrentCode(segment.getAgvId()).getId(), idleFunStaList);
|
//// if (null != funcSta) {
|
//// endCode = codeService.getCacheById(funcSta.getCode());
|
//// }
|
//// }
|
//// if (null == endCode) {
|
//// log.warn("AGV[{}] failed to search destination，there hadn't any idle funSta，TaskTypeType：{}", segment.getAgvId(), FuncStaType.STANDBY);
|
//// return;
|
//// }
|
////
|
//// segment.setState(SegmentStateType.INIT.toString());
|
//// segment.setUpdateTime(now);
|
//// if (!segmentService.updateById(segment)) {
|
//// log.error("Segment [{}] failed to update ！！！", segment.getGroupId() + " - " + segment.getSerial());
|
//// return;
|
//// }
|
////
|
//// // new move seg
|
//// Segment insertSeg = new Segment();
|
//// insertSeg.setUuid(String.valueOf(snowflakeIdWorker.nextId()).substring(3));
|
//// insertSeg.setTravelId(segment.getTravelId());
|
//// insertSeg.setAgvId(segment.getAgvId());
|
//// insertSeg.setTaskId(segment.getTaskId());
|
//// insertSeg.setSerial(segment.getSerial() - 1);
|
//// insertSeg.setEndNode(endCode.getId());
|
//// insertSeg.setPosType(TaskPosDto.PosType.MOVE.toString());
|
//// insertSeg.setState(SegmentStateType.WAITING.toString());
|
//// insertSeg.setMemo(MapDataConstant.RESOLVE_DEADLOCK);
|
//// if (!segmentService.save(insertSeg)) {
|
//// log.error("Segment [{}] failed to save ！！！", segment.getTravelId() + " - " + segment.getSerial());
|
//// return;
|
//// }
|
//// return;
|
//// }
|
//// }
|
//// }
|
//
|
// if (!Cools.isEmpty(segmentService.getByAgvAndState(agv.getId(), SegmentStateType.RUNNING.toString()))) {
|
// return;
|
// }
|
// List<Segment> waitingSegList = segmentService.getByAgvAndState(agv.getId(), SegmentStateType.WAITING.toString());
|
// if (!Cools.isEmpty(waitingSegList)) {
|
// for (Segment waitingSeg : waitingSegList) {
|
// if (!waitingSeg.getId().equals(segment.getId())) {
|
//// log.error("AGV[{}] 任务异常，服务器错误！！！", agv.getUuid());
|
// return;
|
// }
|
// }
|
// }
|
//
|
// // dead lane
|
// if (jamService.count(new LambdaQueryWrapper<Jam>()
|
// .eq(Jam::getJamAgv, agv.getId())
|
// .eq(Jam::getJamSeg, segment.getId())
|
// .eq(Jam::getCycleAvo, 1)
|
// .eq(Jam::getCycleCode, endNode)
|
// .eq(Jam::getState, JamStateType.RUNNING.toString())
|
// ) > 0) {
|
// return;
|
// }
|
//
|
// // execute -----------------------------------------------
|
// // ArrayList<List<TaskPosDto>> list = JSON.parseObject(travel.getTaskContent(), new TypeReference<ArrayList<List<TaskPosDto>>>() {});
|
//
|
// // * sync wave scope
|
// if (!avoidWaveCalculator.calcWaveScope()) {
|
// log.error("failed to calculate avoid wave matrix ...");
|
// return;
|
// }
|
//
|
// // checkout path
|
// Code startCode = codeService.getCacheById(agvDetail.getRecentCode());
|
// Code endCode = codeService.getCacheById(endNode);
|
// long startTime = System.currentTimeMillis();
|
// List<String> pathList = this.checkoutPath(agv, startCode, endCode, segment);
|
//// System.out.println("checkoutPath: " + (System.currentTimeMillis() - startTime));
|
// if (Cools.isEmpty(pathList)) {
|
// return;
|
// }
|
//
|
// List<Segment> segmentList = new ArrayList<>();
|
// segmentList.add(segment);
|
//
|
// String lastCodeData = pathList.get(pathList.size() - 1);
|
// if (!endCode.getData().equals(lastCodeData)) {
|
// // slice
|
// Code lastCode = codeService.getCacheByData(lastCodeData);
|
//
|
//// if (pathList.size() <= MIN_SLICE_PATH_LENGTH) {
|
//// return;
|
//// }
|
//
|
// // revert
|
// segment.setState(SegmentStateType.INIT.toString());
|
// segment.setUpdateTime(now);
|
// if (!segmentService.updateById(segment)) {
|
// log.error("Segment [{}] failed to update ！！！", segment.getGroupId() + " - " + segment.getSerial());
|
// }
|
// segmentList.clear();
|
//
|
// // new move seg
|
// Segment insertSeg = new Segment();
|
// insertSeg.setUuid(String.valueOf(snowflakeIdWorker.nextId()).substring(3));
|
// insertSeg.setTravelId(travel.getId());
|
// insertSeg.setAgvId(agv.getId());
|
// insertSeg.setTaskId(segment.getTaskId());
|
// insertSeg.setSerial(segment.getSerial() - 1);
|
// insertSeg.setEndNode(lastCode.getId());
|
// insertSeg.setPosType(TaskPosDto.PosType.MOVE.toString());
|
// insertSeg.setState(SegmentStateType.WAITING.toString());
|
// if (!segmentService.save(insertSeg)) {
|
// log.error("Segment [{}] failed to save ！！！", segment.getTravelId() + " - " + segment.getSerial());
|
// }
|
// segmentList.add(insertSeg);
|
//
|
// } else {
|
//
|
// // complete first segment then merge behind segment
|
// int serial = segment.getSerial();
|
// boolean interrupt = false;
|
// while (!interrupt) {
|
//
|
// Segment nextStep = segmentService.getNextStepOfInit(travel.getId(), serial);
|
// serial ++;
|
// if (null == nextStep) {
|
// interrupt = true;
|
// } else {
|
// if (nextStep.getEndNode() == endNode) {
|
//
|
// segmentList.add(nextStep);
|
// } else {
|
// interrupt = true;
|
// }
|
// }
|
//
|
// }
|
// }
|
//
|
// mapService.lockPath(null, pathList, agv.getUuid());
|
//
|
// startTime = System.currentTimeMillis();
|
// mainService.generateAction(segment.getAgvId(), segmentList, pathList, now);
|
//// System.out.println("generateAction: " + (System.currentTimeMillis() - startTime));
|
//
|
// } catch (Exception e) {
|
// log.error("TrafficService.trigger", e);
|
// TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
|
//
|
// }
|
// }
|
//
|
// private List<String> checkoutPath(Agv agv, Code startCode, Code endCode, Segment segment) {
|
// Integer lev = null;
|
// String agvNo = agv.getUuid();
|
// Date now = new Date();
|
// Jam jam = jamService.getJam(agv.getId(), startCode.getId(), segment.getId());
|
// BlockSeverityType blockSeverity = BlockSeverityType.query(null == jam ? null : jam.getDuration());
|
// // judge avoid of jam 如果已经在避让点（因为当前车执行了避让任务），那么则不能再去检索之前的阻塞路径
|
// List<Jam> unfinishedOriginJamByCurrAgv = jamService.getUnfinishedOriginJamByAvo(agv.getId(), startCode.getId(), segment.getId());
|
// List<String> blackPath = this.getBlackPathList(unfinishedOriginJamByCurrAgv);
|
//
|
// // 结果集
|
// List<String> pathList = new ArrayList<>();
|
//
|
// // 无障碍解
|
// List<String> unlockPathList = mapService.checkoutPath(agvNo, startCode, endCode, false, blackPath, segment);
|
// // 避让解
|
// List<String> lockPathList = mapService.checkoutPath(agvNo, startCode, endCode, true, blackPath, segment);
|
//
|
// if (!Cools.isEmpty(lockPathList) && // 存在避让解
|
// Math.abs(lockPathList.size() - unlockPathList.size()) <= Arrays.stream(mapDataDispatcher.getCodeMatrix(lev)).mapToInt(row -> row.length).sum() / 10
|
// ) {
|
//
|
// pathList = lockPathList;
|
// } else {
|
//
|
// // preview path
|
// List<String> draftPath = new ArrayList<>(unlockPathList);
|
// if (blockSeverity.equals(BlockSeverityType.SEVERE)) {
|
// unlockPathList.remove(endCode.getData());
|
// blackPath.addAll(unlockPathList);
|
// List<String> newUnlockPathList = mapService.checkoutPath(agvNo, startCode, endCode, false, blackPath, segment);
|
// if (!Cools.isEmpty(newUnlockPathList)) {
|
// draftPath = newUnlockPathList;
|
// }
|
// }
|
// // 可走行路径集合计算
|
// List<BlockVehicleDto> blockVehicleList = this.slicePathAndReturnBlockVehicleList(lev, draftPath, agvNo, pathList); // jamAgvNo may was wave
|
//
|
// if (!Cools.isEmpty(pathList)) {
|
//
|
// if (!pathList.get(pathList.size() - 1).equals(endCode.getData())) {
|
// assert !Cools.isEmpty(blockVehicleList);
|
//
|
// boolean hasUnavoidableBlocks = blockVehicleList.stream().anyMatch(blockVehicleDto -> !blockVehicleDto.isAvoidable());
|
// if (hasUnavoidableBlocks && pathList.size() <= MapDataConstant.MIN_SLICE_PATH_LENGTH) {
|
// log.info("AGV[{}] waiting in place, because the path list is too short...", agvNo);
|
// pathList.clear();
|
// }
|
//
|
// boolean hasCycleJam = blockVehicleList.stream().anyMatch(
|
// blockVehicleDto -> null != jamService.getCycleJam(agv.getId(), segment.getId(), blockVehicleDto.getVehicle())
|
// );
|
// if (hasCycleJam) {
|
// log.info("AGV[{}] waiting in place, because has cycle jam...", agvNo);
|
// pathList.clear();
|
// }
|
// }
|
//
|
// // 无可走行路径
|
// } else {
|
//
|
// if (Cools.isEmpty(blockVehicleList)) {
|
// log.warn("AGV[{}] can't reach to code: {}, because there is too many vehicle in the lane...", agvNo, endCode.getData());
|
// } else {
|
//
|
// assert !Cools.isEmpty(blockVehicleList);
|
// Integer maxJamTimeoutFactor = null;
|
//
|
// // persist jam data
|
// jam = this.createOrUpdateJam(agv, startCode, segment, jam, draftPath);
|
//
|
// // ? has unAvoidable block vehicles
|
// if (blockVehicleList.stream().anyMatch(blockVehicleDto -> !blockVehicleDto.isAvoidable())) {
|
//
|
// // set factor of jam timeout
|
// maxJamTimeoutFactor = 1;
|
// } else {
|
//
|
// // ? already do notify to avoid
|
// if (!Cools.isEmpty(jam.getAvoAgv())
|
// && BlockVehicleDto.customContain(blockVehicleList, agvService.getById(jam.getAvoAgv()).getUuid())) {
|
//
|
// maxJamTimeoutFactor = 4;
|
//
|
// } else {
|
//
|
// // select optimal block vehicle
|
// String blockAgvNo = this.checkoutBestSolutionOfBlocks(blockVehicleList, segment);
|
// if (Cools.isEmpty(blockAgvNo)) {
|
//
|
// maxJamTimeoutFactor = 2;
|
//
|
// } else {
|
//
|
// // block vehicle info
|
// Long blockAgvId = agvService.getAgvId(blockAgvNo);
|
// String blockAgvCode = codeService.getCacheById(agvDetailService.selectMajorByAgvId(blockAgvId).getRecentCode()).getData();
|
//
|
// // create new jam if already notify the avoid vehicle
|
// if (!Cools.isEmpty(jam.getAvoAgv(), jam.getAvoSeg()) && !blockAgvId.equals(jam.getAvoAgv())) {
|
// jam = this.setupNewJam(jam, agv, startCode, segment, draftPath);
|
// }
|
//
|
// do {
|
//
|
// // 阻塞车辆正在原地作业，等待 ===>> 超过等待时间，绕路
|
// List<Segment> runningSegList = segmentService.getByAgvAndState(blockAgvId, SegmentStateType.RUNNING.toString());
|
// if (!Cools.isEmpty(runningSegList)) {
|
// maxJamTimeoutFactor = 1;
|
// break;
|
// }
|
//
|
// // 判断下个任务是否为原地任务，如果是则等待 ===>> 超过等待时间，绕路；如果不是，让阻塞车辆避让
|
// List<Segment> waitingSegList = segmentService.getJustWaitingSeg(blockAgvId);
|
// if (null != waitingSegList
|
// && waitingSegList.stream().anyMatch(
|
// waitingSeg -> waitingSeg.getEndNode().equals(codeService.getCacheByData(blockAgvCode).getId())
|
// )) {
|
// maxJamTimeoutFactor = 1;
|
// break;
|
// }
|
//
|
// // notify block vehicle to avoid
|
// if (this.notifyVehicleAvoid(blockAgvNo, blockAgvCode, draftPath, agvNo, jam)) {
|
// if (jam.getCycleAvo() == 1) {
|
// jam.setCycleCode(endCode.getId());
|
// }
|
// jam.setAvoAgv(blockAgvId);
|
// jam.setNotifyTime(new Date());
|
// if (!jamService.updateById(jam)) {
|
// throw new CoolException(jam.getUuid() + "-jam failed to update！！！");
|
// }
|
// } else {
|
//
|
// maxJamTimeoutFactor = 1;
|
// }
|
//
|
// } while (false);
|
// }
|
//
|
// }
|
//
|
// }
|
//
|
// // handle jam timeout
|
// if (null != maxJamTimeoutFactor) {
|
// if (System.currentTimeMillis() - jam.getStartTime().getTime() > (long) MapDataConstant.MAX_JAM_TIMEOUT * maxJamTimeoutFactor) {
|
//
|
// if (!Cools.isEmpty(lockPathList)) {
|
//
|
// pathList = lockPathList;
|
// } else {
|
// log.error("{}号车辆检索[{}] ===>> [{}]路径失败，原因：{}"
|
// , agvNo, startCode.getData(), endCode.getData(), "路径阻塞超时");
|
// }
|
// } else {
|
// log.warn("{}号车辆正在等待交通堵塞，阻塞车辆：【{}】"
|
// , agvNo
|
// , blockVehicleList.stream().map(BlockVehicleDto::getVehicle).collect(Collectors.toList()).toString()
|
// );
|
// }
|
// }
|
//
|
// }
|
//
|
// }
|
// }
|
//
|
// if (!Cools.isEmpty(pathList)) {
|
//
|
// if (null != jam) {
|
// boolean beDeprecate = false;
|
// if (blockSeverity.equals(BlockSeverityType.SEVERE) && !Cools.isEmpty(jam.getJamPath())) {
|
// List<String> jamPath = GsonUtils.fromJsonToList(jam.getJamPath(), String.class);
|
// if (!this.comparePathLists(jamPath, pathList)) { // jamPath >= pathList
|
// beDeprecate = true;
|
// }
|
// }
|
// jam.setEndTime(now);
|
// jam.setUpdateTime(now);
|
// jam.setState(beDeprecate ? JamStateType.DEPRECATED.toString() : JamStateType.FINISH.toString());
|
// if (jamService.updateById(jam)) {
|
// if (beDeprecate) {
|
// // search previous jam that jamSeg from this segment
|
// List<Jam> previousJams = jamService.list(new LambdaQueryWrapper<Jam>()
|
// .eq(Jam::getJamSeg, segment.getId())
|
// .eq(Jam::getState, JamStateType.FINISH.toString())
|
// );
|
// for (Jam previousJam : previousJams) {
|
// previousJam.setState(JamStateType.DEPRECATED.toString());
|
// previousJam.setUpdateTime(now);
|
// if (!jamService.updateById(previousJam)) {
|
// log.error("Jam[{}] failed to update！！！", previousJam.getUuid());
|
// }
|
// }
|
// }
|
// } else {
|
// log.error("Jam[{}] failed to update！！！", jam.getUuid());
|
// }
|
// }
|
// // deal expired jam
|
// for (Jam expiredJam : jamService.list(new LambdaQueryWrapper<Jam>()
|
// .eq(Jam::getJamAgv, agv.getId())
|
// .eq(Jam::getState, JamStateType.RUNNING.toString()))) {
|
// expiredJam.setEndTime(now);
|
// expiredJam.setUpdateTime(now);
|
// expiredJam.setState(JamStateType.DEPRECATED.toString());
|
// if (!jamService.updateById(expiredJam)) {
|
// log.error("Jam[{}] failed to update！！！", expiredJam.getUuid());
|
// }
|
// }
|
//
|
// }
|
//
|
// return pathList;
|
// }
|
//
|
// private List<BlockVehicleDto> slicePathAndReturnBlockVehicleList(Integer lev, List<String> fullPathList, String agvNo, List<String> pathList) {
|
// List<BlockVehicleDto> blockVehicleList = new ArrayList<>();
|
//
|
// String[][] waveMatrix = mapDataDispatcher.getWaveMatrix(lev);
|
// List<int[]> codeMatrixIdxList = mapDataDispatcher.getCodeMatrixIdxList(lev, fullPathList);
|
// for (int i = 0; i < fullPathList.size(); i++) {
|
// String codeData = fullPathList.get(i);
|
// int[] codeMatrixIdx = codeMatrixIdxList.get(i);
|
//
|
// String waveNode = waveMatrix[codeMatrixIdx[0]][codeMatrixIdx[1]];
|
// assert !waveNode.equals(WaveNodeType.DISABLE.val);
|
// if (!waveNode.equals(WaveNodeType.ENABLE.val)) {
|
// List<String> waveNodeList = MapDataUtils.parseWaveNode(waveNode);
|
// List<String> otherWaveList = MapDataUtils.hasOtherWave(waveNodeList, agvNo);
|
// if (!Cools.isEmpty(otherWaveList)) {
|
// for (String otherWave : otherWaveList) {
|
// if (mapService.isWalkingByVehicle(lev, otherWave)) {
|
// blockVehicleList.add(new BlockVehicleDto(otherWave, false));
|
// } else {
|
// blockVehicleList.add(new BlockVehicleDto(otherWave, true));
|
// }
|
// }
|
// break;
|
// }
|
// }
|
//
|
// pathList.add(codeData);
|
// }
|
//
|
// if (pathList.size() <= 1) {
|
// pathList.clear();
|
// }
|
//
|
// return blockVehicleList.stream().distinct().collect(Collectors.toList());
|
// }
|
//
|
// /**
|
// * avoidPathList include wave node and dynamic node
|
// */
|
// private boolean notifyVehicleAvoid(String agvNo, String agvPosCode, List<String> avoidPathList, String sponsor, Jam jam) {
|
// Long agvId = agvService.getAgvId(agvNo);
|
// if (!Cools.isEmpty(segmentService.getByAgvAndState(agvId, SegmentStateType.RUNNING.toString()))) {
|
// log.warn("{}号车辆避让失败，存在进行中任务！！！", agvNo);
|
// return false;
|
// }
|
//
|
// int[] startMapIdx = mapDataDispatcher.getCodeMatrixIdx(null, agvPosCode);
|
// RetreatNavigateNode startNode = new RetreatNavigateNode(startMapIdx[0], startMapIdx[1], agvPosCode);
|
//
|
// assert avoidPathList.size() >= 2;
|
// RetreatNavigateNode finalNode = retreatNavigateService.execute(agvNo, startNode, avoidPathList, sponsor, jam);
|
// if (null == finalNode) {
|
// log.warn("{}号车辆避让失败，检索避让点失败！！！", agvNo);
|
// return false;
|
// }
|
//
|
// String endCodeData = finalNode.getCodeData();
|
// Code endCode = codeService.getCacheByData(endCodeData);
|
//
|
// List<Segment> waitingSegList = segmentService.getByAgvAndState(agvId, SegmentStateType.WAITING.toString());
|
// if (!Cools.isEmpty(waitingSegList)) {
|
//
|
// if (waitingSegList.size() > 1) {
|
// log.error("避让通知失败，{}号车辆存在多个等待中的Segment！！！", agvNo);
|
// return false;
|
// }
|
// // revert
|
// Date now = new Date();
|
// for (Segment seg : waitingSegList) {
|
// seg.setState(SegmentStateType.INIT.toString());
|
// seg.setUpdateTime(now);
|
// if (!segmentService.updateById(seg)) {
|
// log.error("Segment [{}] 更新失败 ！！！", seg.getTravelId() + " - " + seg.getSerial());
|
// }
|
// }
|
// Segment segment = waitingSegList.get(0);
|
//
|
// Segment insertSeg = new Segment();
|
// insertSeg.setUuid(String.valueOf(snowflakeIdWorker.nextId()).substring(3));
|
// insertSeg.setTravelId(segment.getTravelId());
|
// insertSeg.setAgvId(agvId);
|
// insertSeg.setTaskId(segment.getTaskId());
|
// insertSeg.setSerial(segment.getSerial() - 1);
|
// insertSeg.setEndNode(endCode.getId());
|
// insertSeg.setPosType(TaskPosDto.PosType.MOVE.toString());
|
// insertSeg.setState(SegmentStateType.WAITING.toString());
|
// if (!segmentService.save(insertSeg)) {
|
// log.error("Segment [{}] 保存失败 ！！！", segment.getTravelId() + " - " + segment.getSerial());
|
// return false;
|
// } else {
|
// jam.setAvoSeg(insertSeg.getId());
|
// jam.setAvoCode(endCode.getId());
|
// }
|
//
|
// } else {
|
//
|
// return mainLockWrapService.buildMinorTask(agvId, TaskTypeType.MOVE, endCodeData, jam);
|
// }
|
//
|
// return true;
|
// }
|
//
|
// private Jam createOrUpdateJam(Agv agv, Code startCode, Segment segment, Jam jam, List<String> jamPath) {
|
// if (jam == null) {
|
// jam = new Jam();
|
// jam.setUuid(String.valueOf(snowflakeIdWorker.nextId()).substring(3));
|
// jam.setJamAgv(agv.getId());
|
// jam.setJamCode(startCode.getId());
|
// jam.setJamSeg(segment.getId());
|
// jam.setJamPath(GsonUtils.toJson(jamPath));
|
// jam.setStartTime(new Date());
|
// jam.setState(JamStateType.RUNNING.toString());
|
// if (!jamService.save(jam)) {
|
// log.error("AGV[{}] failed to save jam", agv.getUuid());
|
// throw new CoolException("failed to save jam");
|
// }
|
// } else {
|
// jam.setDuration(System.currentTimeMillis() - jam.getStartTime().getTime());
|
// if (!jamService.updateById(jam)) {
|
// log.error("AGV[{}] failed to update jam", agv.getUuid());
|
// }
|
// }
|
// return jam;
|
// }
|
//
|
// private Jam setupNewJam(Jam originJam, Agv agv, Code startCode, Segment segment, List<String> draftPath) {
|
// originJam.setUpdateTime(new Date());
|
// originJam.setState(JamStateType.FINISH.toString());
|
// if (!jamService.updateById(originJam)) {
|
// log.error("Jam[{}] failed to update", originJam.getUuid());
|
// return originJam;
|
// } else {
|
// return this.createOrUpdateJam(
|
// agv
|
// , startCode
|
// , segment
|
// , null
|
// , draftPath
|
// );
|
// }
|
// }
|
//
|
// private List<String> getBlackPathList(List<Jam> unfinishedOriginJamByCurrAgv) {
|
// List<String> blackPathList = new ArrayList<>();
|
// Integer lev = MapDataDispatcher.MAP_DEFAULT_LEV;
|
// if (!Cools.isEmpty(unfinishedOriginJamByCurrAgv)) {
|
// for (Jam jam : unfinishedOriginJamByCurrAgv) {
|
// if (!Cools.isEmpty(jam.getJamPath())) {
|
//
|
// List<String> list = GsonUtils.fromJsonToList(jam.getJamPath(), String.class);
|
//
|
// Agv jamAgv = agvService.getById(jam.getJamAgv());
|
// List<String> jamDynamicNodes = mapService.queryCodeListFromDynamicNode(lev, jamAgv.getUuid());
|
// // jamDynamicNodes has sorted
|
// String firstCodeNode = jamDynamicNodes.stream().findFirst().orElse(null);
|
//
|
// if (!Cools.isEmpty(firstCodeNode)) {
|
// int idx = list.indexOf(firstCodeNode);
|
// if (idx != -1) {
|
// list = new ArrayList<>(list.subList(idx, list.size()));
|
//
|
// // the wave of first node
|
// Double avoidDistance = MapDataUtils.getVehicleWaveSafeDistance(
|
// agvModelService.getById(jamAgv.getAgvModel()).getDiameter(),
|
// MapDataConstant.MAX_DISTANCE_BETWEEN_ADJACENT_AGV_FACTOR
|
// );
|
// List<String> waveCodeList = mapService.getWaveScopeByCode(lev, firstCodeNode, avoidDistance)
|
// .stream().map(NavigateNode::getCodeData).distinct().collect(Collectors.toList());
|
// list.addAll(waveCodeList);
|
// } else {
|
// // 如果被阻塞车辆已经不在原来的阻塞路径中，考虑避让车走行时不需要把之前的阻塞路径加入黑名单
|
// list = new ArrayList<>();
|
// }
|
// }
|
//
|
// blackPathList.addAll(list);
|
// }
|
// }
|
// }
|
// return blackPathList.stream().distinct().collect(Collectors.toList());
|
// }
|
//
|
// private String checkoutBestSolutionOfBlocks(List<BlockVehicleDto> blockVehicleList, Segment segment) {
|
// assert !Cools.isEmpty(blockVehicleList);
|
// for (BlockVehicleDto blockVehicleDto : blockVehicleList) {
|
// if (!blockVehicleDto.isAvoidable()) {
|
// continue;
|
// }
|
// // 当前vehicle正在进行避让作业
|
// if (!Cools.isEmpty(jamService.getUnfinishedAvoSegByAvo(blockVehicleDto.getVehicle(), null))) {
|
// continue;
|
// }
|
// return blockVehicleDto.getVehicle();
|
// }
|
// return null;
|
// }
|
//
|
// public boolean comparePathLists(List<String> list1, List<String> list2) {
|
// if (list1.equals(list2)) {
|
// return true;
|
// }
|
// if (list1.containsAll(list2)) {
|
// return true;
|
// }
|
// return false;
|
// }
|
//
|
// /**
|
// * 1. the jam was deprecated
|
// * 2. the jam segment is finished
|
// *
|
// * all these by avoid segment
|
// */
|
// private boolean isExpiredJamByAvo(Long avoSeg) {
|
// List<Jam> jamList = jamService.list(new LambdaQueryWrapper<Jam>()
|
//// .eq(Jam::getAvoAgv, avoAgv)
|
// .eq(Jam::getAvoSeg, avoSeg));
|
// if (Cools.isEmpty(jamList)) {
|
// return false;
|
// }
|
// if (jamList.size() > 1) {
|
// log.error("AvoSeg[id = {}] seg data has exception, result in two jams", avoSeg);
|
// }
|
// Jam jam = jamList.get(0);
|
// if (jam.getState().equals(JamStateType.DEPRECATED.toString())) {
|
// return true;
|
// }
|
// Segment jamSegment = segmentService.getById(jam.getJamSeg());
|
// if (jamSegment.getState().equals(SegmentStateType.FINISH.toString())) {
|
// return true;
|
// }
|
// return false;
|
// }
|
//
|
//}
|
