From ebd2f4397a92c6a5096de1b86d59154363344720 Mon Sep 17 00:00:00 2001
From: vincentlu <t1341870251@gmail.com>
Date: 星期二, 13 五月 2025 08:48:15 +0800
Subject: [PATCH] #

---
 zy-acs-manager/src/main/java/com/zy/acs/manager/core/service/TrafficService.java |  124 ++++++++++++++++++++++++++++++++--------
 1 files changed, 98 insertions(+), 26 deletions(-)

diff --git a/zy-acs-manager/src/main/java/com/zy/acs/manager/core/service/TrafficService.java b/zy-acs-manager/src/main/java/com/zy/acs/manager/core/service/TrafficService.java
index 86e42f5..775f301 100644
--- a/zy-acs-manager/src/main/java/com/zy/acs/manager/core/service/TrafficService.java
+++ b/zy-acs-manager/src/main/java/com/zy/acs/manager/core/service/TrafficService.java
@@ -71,6 +71,10 @@
     private JamService jamService;
     @Autowired
     private AvoidWaveCalculator avoidWaveCalculator;
+    @Autowired
+    private TaskService taskService;
+    @Autowired
+    private FuncStaService funcStaService;
 
     @Transactional
     public synchronized void trigger(Segment segment) {
@@ -99,6 +103,77 @@
             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锛宼here hadn't any idle funSta锛孴askTypeType锛歿}", 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;
             }
@@ -133,9 +208,11 @@
             }
 
             // checkout path
-            Code startCode = codeService.getById(agvDetail.getRecentCode());
-            Code endCode = codeService.getById(endNode);
+            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;
             }
@@ -146,7 +223,7 @@
             String lastCodeData = pathList.get(pathList.size() - 1);
             if (!endCode.getData().equals(lastCodeData)) {
                 // slice
-                Code lastCode = codeService.selectByData(lastCodeData);
+                Code lastCode = codeService.getCacheByData(lastCodeData);
 
 //                if (pathList.size() <= MIN_SLICE_PATH_LENGTH) {
 //                    return;
@@ -200,7 +277,9 @@
 
             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);
@@ -305,7 +384,7 @@
 
                                 // block vehicle info
                                 Long blockAgvId = agvService.getAgvId(blockAgvNo);
-                                String blockAgvCode = codeService.getById(agvDetailService.selectByAgvId(blockAgvId).getRecentCode()).getData();
+                                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())) {
@@ -325,7 +404,7 @@
                                     List<Segment> waitingSegList = segmentService.getJustWaitingSeg(blockAgvId);
                                     if (null != waitingSegList
                                             && waitingSegList.stream().anyMatch(
-                                            waitingSeg -> waitingSeg.getEndNode().equals(codeService.selectByData(blockAgvCode).getId())
+                                            waitingSeg -> waitingSeg.getEndNode().equals(codeService.getCacheByData(blockAgvCode).getId())
                                     )) {
                                         maxJamTimeoutFactor = 1;
                                         break;
@@ -429,19 +508,20 @@
     private List<BlockVehicleDto> slicePathAndReturnBlockVehicleList(Integer lev, List<String> fullPathList, String agvNo, List<String> pathList) {
         List<BlockVehicleDto> blockVehicleList = new ArrayList<>();
 
-//        DynamicNode[][] dynamicMatrix = mapDataDispatcher.getDynamicMatrix(lev);
         String[][] waveMatrix = mapDataDispatcher.getWaveMatrix(lev);
-        for (String code : fullPathList) {
-            int[] node = mapDataDispatcher.getCodeMatrixIdx(lev, code);
+        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[node[0]][node[1]];
+            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 (1 < mapDataDispatcher.queryCodeListFromDynamicNode(lev, otherWave).size()) {
+                        if (mapService.isWalkingByVehicle(lev, otherWave)) {
                             blockVehicleList.add(new BlockVehicleDto(otherWave, false));
                         } else {
                             blockVehicleList.add(new BlockVehicleDto(otherWave, true));
@@ -451,15 +531,7 @@
                 }
             }
 
-//            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)) {
-//                blockVehicleList.add(vehicle);
-//                break;
-//            }
-
-            pathList.add(code);
+            pathList.add(codeData);
         }
 
         if (pathList.size() <= 1) {
@@ -473,8 +545,8 @@
      * 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()))) {
+        Long agvId = agvService.getAgvId(agvNo);
+        if (!Cools.isEmpty(segmentService.getByAgvAndState(agvId, SegmentStateType.RUNNING.toString()))) {
             log.warn("{}鍙疯溅杈嗛伩璁╁け璐ワ紝瀛樺湪杩涜涓换鍔★紒锛侊紒", agvNo);
             return false;
         }
@@ -490,9 +562,9 @@
         }
 
         String endCodeData = finalNode.getCodeData();
-        Code endCode = codeService.selectByData(endCodeData);
+        Code endCode = codeService.getCacheByData(endCodeData);
 
-        List<Segment> waitingSegList = segmentService.getByAgvAndState(agv.getId(), SegmentStateType.WAITING.toString());
+        List<Segment> waitingSegList = segmentService.getByAgvAndState(agvId, SegmentStateType.WAITING.toString());
         if (!Cools.isEmpty(waitingSegList)) {
 
             if (waitingSegList.size() > 1) {
@@ -513,7 +585,7 @@
             Segment insertSeg = new Segment();
             insertSeg.setUuid(String.valueOf(snowflakeIdWorker.nextId()).substring(3));
             insertSeg.setTravelId(segment.getTravelId());
-            insertSeg.setAgvId(agv.getId());
+            insertSeg.setAgvId(agvId);
             insertSeg.setTaskId(segment.getTaskId());
             insertSeg.setSerial(segment.getSerial() - 1);
             insertSeg.setEndNode(endCode.getId());
@@ -529,7 +601,7 @@
 
         } else {
 
-            return mainLockWrapService.buildMinorTask(agv, TaskTypeType.MOVE, endCodeData, jam);
+            return mainLockWrapService.buildMinorTask(agvId, TaskTypeType.MOVE, endCodeData, jam);
         }
 
         return true;
@@ -585,7 +657,7 @@
                     List<String> list = GsonUtils.fromJsonToList(jam.getJamPath(), String.class);
 
                     Agv jamAgv = agvService.getById(jam.getJamAgv());
-                    List<String> jamDynamicNodes = mapDataDispatcher.queryCodeListFromDynamicNode(lev, jamAgv.getUuid());
+                    List<String> jamDynamicNodes = mapService.queryCodeListFromDynamicNode(lev, jamAgv.getUuid());
                     // jamDynamicNodes has sorted
                     String firstCodeNode = jamDynamicNodes.stream().findFirst().orElse(null);
 

--
Gitblit v1.9.1