#

luxiaotao1123

2024-12-17 d3d3857cda8b4307d8f03bf15ec9fb2c98c34b64

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

@@ -2,6 +2,7 @@

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;
@@ -11,6 +12,7 @@
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.*;
@@ -59,7 +61,7 @@
    @Autowired
    private SnowflakeIdWorker snowflakeIdWorker;
    @Autowired
    private ActionService actionService;
    private AgvModelService agvModelService;
    @Autowired
    private RetreatNavigateService retreatNavigateService;
    @Autowired
@@ -103,6 +105,12 @@
                    .eq(Jam::getCycleCode, endNode)
                    .eq(Jam::getState, JamStateType.RUNNING.toString())
            ) > 0) {
                return;
            }

            // deprecate jam
            if (this.isExpiredJamByAvo(segment.getId())) {
                mainService.settleSegmentList(Utils.singletonList(segment), null);
                return;
            }

@@ -195,7 +203,7 @@
        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
        // judge avoid of jam 如果已经在避让点（因为当前车执行了避让任务），那么则不能再去检索之前的阻塞路径
        List<Jam> unfinishedOriginJamByCurrAgv = jamService.getUnfinishedOriginJamByAvo(agv.getId(), startCode.getId(), segment.getId());
        List<String> blackPath = this.getBlackPathList(unfinishedOriginJamByCurrAgv);

@@ -271,12 +279,12 @@
                        if (!Cools.isEmpty(jam.getAvoAgv())
                                && BlockVehicleDto.customContain(blockVehicleList, agvService.getById(jam.getAvoAgv()).getUuid())) {

                            maxJamTimeoutFactor = 5;
                            maxJamTimeoutFactor = 4;

                        } else {

                            // select optimal block vehicle
                            String blockAgvNo = this.checkoutBestSolutionOfBlocks(blockVehicleList);
                            String blockAgvNo = this.checkoutBestSolutionOfBlocks(blockVehicleList, segment);
                            if (Cools.isEmpty(blockAgvNo)) {

                                maxJamTimeoutFactor = 2;
@@ -286,6 +294,11 @@
                                // block vehicle info
                                Agv blockAgv = agvService.selectByUuid(blockAgvNo);
                                String blockAgvCode = codeService.getById(agvDetailService.selectByAgvId(blockAgv.getId()).getRecentCode()).getData();

                                // create new jam if already notify the avoid vehicle
                                if (!Cools.isEmpty(jam.getAvoAgv(), jam.getAvoSeg()) && !blockAgv.getId().equals(jam.getAvoAgv())) {
                                    jam = this.setupNewJam(jam, agv, startCode, segment, draftPath);
                                }

                                do {

@@ -355,10 +368,32 @@
        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(JamStateType.FINISH.toString());
                if (!jamService.updateById(jam)) {
                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());
                }
            }
@@ -368,7 +403,7 @@
                    .eq(Jam::getState, JamStateType.RUNNING.toString()))) {
                expiredJam.setEndTime(now);
                expiredJam.setUpdateTime(now);
                expiredJam.setState(JamStateType.FINISH.toString());
                expiredJam.setState(JamStateType.DEPRECATED.toString());
                if (!jamService.updateById(expiredJam)) {
                    log.error("Jam[{}] failed to update！！！", expiredJam.getUuid());
                }
@@ -444,7 +479,6 @@

        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)) {
@@ -478,6 +512,7 @@
                return false;
            } else {
                jam.setAvoSeg(insertSeg.getId());
                jam.setAvoCode(endCode.getId());
            }

        } else {
@@ -511,8 +546,26 @@
        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())) {
@@ -520,7 +573,7 @@
                    List<String> list = GsonUtils.fromJsonToList(jam.getJamPath(), String.class);

                    Agv jamAgv = agvService.getById(jam.getJamAgv());
                    List<String> jamDynamicNodes = mapDataDispatcher.queryCodeListFromDynamicNode(null, jamAgv.getUuid());
                    List<String> jamDynamicNodes = mapDataDispatcher.queryCodeListFromDynamicNode(lev, jamAgv.getUuid());
                    // jamDynamicNodes has sorted
                    String firstCodeNode = jamDynamicNodes.stream().findFirst().orElse(null);

@@ -528,6 +581,18 @@
                        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<>();
                        }
                    }

@@ -538,18 +603,56 @@
        return blackPathList.stream().distinct().collect(Collectors.toList());
    }

    private String checkoutBestSolutionOfBlocks(List<BlockVehicleDto> blockVehicleList) {
    private String checkoutBestSolutionOfBlocks(List<BlockVehicleDto> blockVehicleList, Segment segment) {
        assert !Cools.isEmpty(blockVehicleList);
        for (BlockVehicleDto blockVehicleDto : blockVehicleList) {
            if (!blockVehicleDto.isAvoidable()) {
                continue;
            }
            // 没有避让中的任务
            if (Cools.isEmpty(jamService.getUnfinishedAvoSegByAvo(blockVehicleDto.getVehicle(), null))) {
                return blockVehicleDto.getVehicle();
            // 当前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;
    }

}