package com.zy.acs.manager.core.service;
|
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.zy.acs.common.utils.RedisSupport;
|
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.domain.TaskPosDto;
|
import com.zy.acs.manager.core.service.astart.DynamicNodeType;
|
import com.zy.acs.manager.core.service.astart.MapDataDispatcher;
|
import com.zy.acs.manager.core.service.astart.RetreatNavigateNode;
|
import com.zy.acs.manager.core.service.astart.WaveNodeType;
|
import com.zy.acs.manager.core.service.astart.domain.DynamicNode;
|
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 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;
|
|
/**
|
* Wavefront
|
* Created by vincent on 6/25/2024
|
*/
|
@Slf4j
|
@Component
|
public class TwTrafficService {
|
|
public static final Integer MIN_SLICE_PATH_LENGTH = 3;
|
|
public static final Integer timeoutDuration = 5 * 1000;
|
|
private final RedisSupport redis = RedisSupport.defaultRedisSupport;
|
|
@Autowired
|
private AgvService agvService;
|
@Autowired
|
private AgvDetailService agvDetailService;
|
@Autowired
|
private CodeService codeService;
|
@Autowired
|
private TravelService travelService;
|
@Autowired
|
private SegmentService segmentService;
|
@Autowired
|
private MainService mainService;
|
@Autowired
|
private MapService mapService;
|
@Autowired
|
private MapDataDispatcher mapDataDispatcher;
|
@Autowired
|
private SnowflakeIdWorker snowflakeIdWorker;
|
@Autowired
|
private ActionService actionService;
|
@Autowired
|
private RetreatNavigateService retreatNavigateService;
|
@Autowired
|
private TaskService taskService;
|
@Autowired
|
private JamService jamService;
|
@Autowired
|
private AvoidWaveCalculator avoidWaveCalculator;
|
|
@Transactional
|
public synchronized void trigger(Segment segment) {
|
try {
|
Date now = new Date();
|
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;
|
}
|
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())) {
|
return;
|
}
|
}
|
}
|
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>>>() {});
|
|
// get path list
|
avoidWaveCalculator.calcWaveScope(); // * sync wave scope
|
|
// checkout path
|
Code startCode = codeService.getById(agvDetail.getRecentCode());
|
Code endCode = codeService.getById(endNode);
|
List<String> pathList = this.checkoutPath(agv, startCode, endCode, segment);
|
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.selectByData(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 [{}] 保存失败 ！！！", 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());
|
|
mainService.generateAction(segment.getAgvId(), segmentList, pathList);
|
|
} 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());
|
|
// 结果集
|
List<String> pathList = new ArrayList<>();
|
|
// 无障碍解
|
List<String> unlockPathList = mapService.checkoutPath(agvNo, startCode, endCode, false);
|
// 避让解
|
List<String> lockPathList = mapService.checkoutPath(agvNo, startCode, endCode, true);
|
|
if (Cools.isEmpty(lockPathList)) {
|
return pathList;
|
}
|
|
pathList = lockPathList;
|
|
|
long currentTime = System.currentTimeMillis();
|
long estimatedTime = currentTime;
|
|
for (int i = 0; i < pathList.size() - 1; i++) {
|
String fromCode = pathList.get(i);
|
String toCode = pathList.get(i + 1);
|
String key = fromCode + "_" + toCode;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
if (!Cools.isEmpty(lockPathList) && // 存在避让解
|
Math.abs(lockPathList.size() - unlockPathList.size()) <= Arrays.stream(mapDataDispatcher.getCodeMatrix(lev)).mapToInt(row -> row.length).sum() / 10
|
) {
|
|
pathList = lockPathList;
|
} else {
|
|
// 可走行路径集合计算
|
List<String> jamVehicleList = this.getSliceAndReturnJamVehicleList(lev, unlockPathList, agvNo, pathList); // jamAgvNo may was wave
|
|
if (!Cools.isEmpty(pathList)) {
|
|
if (!Cools.isEmpty(jamVehicleList) && !pathList.get(pathList.size() - 1).equals(endCode.getData())) {
|
String jamAgvNo = jamVehicleList.get(0);
|
if (mapDataDispatcher.queryCodeListFromDynamicNode(null, jamAgvNo).size() > 1 && pathList.size() <= MIN_SLICE_PATH_LENGTH) {
|
pathList.clear();
|
}
|
}
|
|
// 无可走行路径
|
} else {
|
|
// 阻塞车辆列表
|
assert !Cools.isEmpty(jamVehicleList);
|
|
String jamAgvNo = jamVehicleList.get(0);
|
|
boolean initJamCache = false;
|
if (null == jam) {
|
jam = new Jam();
|
jam.setUuid(String.valueOf(snowflakeIdWorker.nextId()).substring(3));
|
jam.setJamAgv(agv.getId());
|
jam.setJamCode(startCode.getId());
|
jam.setJamSeg(segment.getId());
|
jam.setStartTime(now);
|
jam.setState(JamStateType.RUNNING.toString());
|
if (!jamService.save(jam)) {
|
log.error("{}号车辆在{}定位被阻塞，记录阻塞状态失败！！！", agvNo, startCode.getData());
|
return pathList;
|
}
|
initJamCache = true;
|
}
|
long previousTimestamp = jam.getStartTime().getTime();
|
|
// jam vehicle info
|
Agv jamAgv = agvService.selectByUuid(jamAgvNo);
|
String jamAgvCode = codeService.getById(agvDetailService.selectByAgvId(jamAgv.getId()).getRecentCode()).getData();
|
|
// jam vehicle dynamic on map matrix
|
List<String> jamCodeList = mapDataDispatcher.queryCodeListFromDynamicNode(lev, jamAgvNo);
|
|
// 路径阻塞
|
if (jamCodeList.size() > 1) {
|
if (System.currentTimeMillis() - previousTimestamp > timeoutDuration) {
|
|
if (!Cools.isEmpty(lockPathList)) {
|
|
pathList = lockPathList;
|
} else {
|
log.error("{}号车辆检索[{}] ===>> [{}]路径失败，原因：{}"
|
, agvNo, startCode.getData(), endCode.getData(), "路径阻塞超时");
|
}
|
} else {
|
log.info("{}号车辆正在等待交通堵塞，阻塞车辆：【{}】", agvNo, jamAgvNo);
|
}
|
|
// 车辆阻塞
|
} else {
|
|
// 已经通知车辆避让
|
if (!Cools.isEmpty(jam.getAvoAgv())) {
|
assert !Cools.isEmpty(jam.getNotifyTime());
|
|
if (System.currentTimeMillis() - jam.getNotifyTime().getTime() > timeoutDuration) {
|
log.warn("{}号车辆阻塞时间过长！！！已通知避让车辆【{}】...", agvNo, jam.getAvoAgv$());
|
}
|
return pathList;
|
}
|
|
do {
|
|
// 阻塞车辆正在作业，等待 ===>> 超过等待时间，绕路
|
List<Segment> runningSegList = segmentService.getByAgvAndState(jamAgv.getId(), SegmentStateType.RUNNING.toString());
|
if (!Cools.isEmpty(runningSegList)) {
|
|
if (System.currentTimeMillis() - previousTimestamp > timeoutDuration) {
|
|
if (!Cools.isEmpty(lockPathList)) {
|
pathList = lockPathList;
|
} else {
|
log.error("{}号车辆检索[{}] ===>> [{}]路径失败，原因：{}"
|
, agvNo, startCode.getData(), endCode.getData(), "车辆阻塞超时");
|
}
|
} else {
|
log.info("{}号车辆正在等待交通堵塞，阻塞车辆：【{}】", agvNo, jamAgvNo);
|
}
|
|
break;
|
}
|
|
// 判断下个任务是否为原地任务，如果是则等待 ===>> 超过等待时间，绕路；如果不是，让阻塞车辆避让
|
Segment waitingSeg = segmentService.getJustWaitingSeg(jamAgv.getId());
|
if (null != waitingSeg) {
|
|
// 如果阻塞车辆待执行任务处于原地，则不能通知它避让
|
if (waitingSeg.getEndNode().equals(codeService.selectByData(jamAgvCode).getId())) {
|
|
if (System.currentTimeMillis() - previousTimestamp > Math.max((timeoutDuration / 30), (5 * 1000))) {
|
|
if (!Cools.isEmpty(lockPathList)) {
|
pathList = lockPathList;
|
} else {
|
log.error("{}号车辆检索[{}] ===>> [{}]路径失败，原因：{}"
|
, agvNo, startCode.getData(), endCode.getData(), "车辆阻塞超时");
|
}
|
} else {
|
log.info("{}号车辆正在等待交通堵塞，阻塞车辆：【{}】", agvNo, jamAgvNo);
|
}
|
|
break;
|
}
|
}
|
|
// 通知阻塞车辆避让
|
if (this.notifyVehicleAvoid(jamAgvNo, jamAgvCode, unlockPathList, agvNo, jam)) {
|
|
if (jam.getCycleAvo() == 1) {
|
jam.setCycleCode(endCode.getId());
|
}
|
jam.setAvoAgv(jamAgv.getId());
|
jam.setNotifyTime(new Date());
|
if (!jamService.updateById(jam)) {
|
// log.error("{}编号阻塞记录更新失败！！！", jam.getUuid());
|
throw new CoolException(jam.getUuid() + "编号阻塞记录更新失败！！！");
|
}
|
} else {
|
|
if (System.currentTimeMillis() - previousTimestamp > timeoutDuration) {
|
|
if (!Cools.isEmpty(lockPathList)) {
|
pathList = lockPathList;
|
} else {
|
log.error("{}号车辆检索[{}] ===>> [{}]路径失败，原因：{}"
|
, agvNo, startCode.getData(), endCode.getData(), "车辆阻塞超时");
|
}
|
} else {
|
log.info("{}号车辆正在等待交通堵塞，阻塞车辆：【{}】", agvNo, jamAgvNo);
|
}
|
}
|
|
} while (false);
|
|
}
|
|
if (!initJamCache) {
|
jam.setDuration(System.currentTimeMillis() - jam.getStartTime().getTime());
|
if (!jamService.updateById(jam)) {
|
log.error("{}编号阻塞记录更新失败！！！", jam.getUuid());
|
}
|
}
|
|
}
|
|
}
|
|
if (!Cools.isEmpty(pathList)) {
|
|
if (null != jam) {
|
jam.setEndTime(now);
|
jam.setUpdateTime(now);
|
jam.setState(JamStateType.FINISH.toString());
|
if (!jamService.updateById(jam)) {
|
log.error("{}编号阻塞记录完成修改失败！！！", jam.getUuid());
|
}
|
}
|
// 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.FINISH.toString());
|
if (!jamService.updateById(expiredJam)) {
|
log.error("{}编号阻塞记录完成修改失败！！！", expiredJam.getUuid());
|
}
|
}
|
|
}
|
|
return pathList;
|
}
|
|
private List<String> getSliceAndReturnJamVehicleList(Integer lev, List<String> fullPathList, String agvNo, List<String> input) {
|
List<String> jamVehicleList = new ArrayList<>();
|
|
DynamicNode[][] dynamicMatrix = mapDataDispatcher.getDynamicMatrix(lev);
|
String[][] waveMatrix = mapDataDispatcher.getWaveMatrix(lev);
|
for (String code : fullPathList) {
|
int[] node = mapDataDispatcher.getCodeMatrixIdx(lev, code);
|
|
String waveNode = waveMatrix[node[0]][node[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)) {
|
jamVehicleList.addAll(otherWaveList);
|
break;
|
}
|
}
|
|
DynamicNode dynamicNode = dynamicMatrix[node[0]][node[1]];
|
String vehicle = dynamicNode.getVehicle();
|
assert !vehicle.equals(DynamicNodeType.BLOCK.val);
|
if (!vehicle.equals(DynamicNodeType.ACCESS.val) && !vehicle.equals(agvNo)) {
|
jamVehicleList.add(vehicle);
|
break;
|
}
|
|
input.add(code);
|
}
|
|
if (input.size() <= 1) {
|
input.clear();
|
}
|
|
return jamVehicleList;
|
}
|
|
/**
|
* avoidPathList include wave node and dynamic node
|
*/
|
private boolean notifyVehicleAvoid(String agvNo, String agvPosCode, List<String> avoidPathList, String sponsor, Jam jam) {
|
Agv agv = agvService.selectByUuid(agvNo);
|
if (!Cools.isEmpty(segmentService.getByAgvAndState(agv.getId(), 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.selectByData(endCodeData);
|
jam.setAvoCode(endCode.getId());
|
|
List<Segment> waitingSegList = segmentService.getByAgvAndState(agv.getId(), SegmentStateType.WAITING.toString());
|
if (!Cools.isEmpty(waitingSegList)) {
|
|
// 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(agv.getId());
|
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 {
|
|
return mainService.buildMinorTask(agv, null, TaskTypeType.MOVE, endCodeData);
|
}
|
|
return true;
|
}
|
|
}
|
