From efabc6ba991acfd01d38bb0bf4e8cfd772416617 Mon Sep 17 00:00:00 2001
From: vincentlu <t1341870251@gmail.com>
Date: 星期一, 05 一月 2026 13:07:39 +0800
Subject: [PATCH] #

---
 zy-acs-manager/src/main/java/com/zy/acs/manager/core/service/TrafficService.java |  104 +++++++++++++++++++++++++++++++++++++++++++++++-----
 1 files changed, 94 insertions(+), 10 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 8dc6dbe..bb3cd44 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) {
@@ -92,13 +96,83 @@
 
             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锛宼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;
             }
@@ -127,15 +201,15 @@
             //        ArrayList<List<TaskPosDto>> list = JSON.parseObject(travel.getTaskContent(), new TypeReference<ArrayList<List<TaskPosDto>>>() {});
 
             // * sync wave scope
-            if (!avoidWaveCalculator.calcWaveScope()) {
+            if (!avoidWaveCalculator.calcWaveScope(agvModelService.getByAgvId(agv.getId()))) {
                 log.error("failed to calculate avoid wave matrix ...");
                 return;
             }
 
             // checkout path
-            Code startCode = codeService.getCacheById(agvDetail.getRecentCode());
+            Code startCode = agvDetailService.getCurrentCode(travel.getAgvId());
             Code endCode = codeService.getCacheById(endNode);
-            long startTime = System.currentTimeMillis();
+//            long startTime = System.currentTimeMillis();
             List<String> pathList = this.checkoutPath(agv, startCode, endCode, segment);
 //            System.out.println("checkoutPath: " + (System.currentTimeMillis() - startTime));
             if (Cools.isEmpty(pathList)) {
@@ -173,7 +247,7 @@
                 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());
+                    log.error("Segment [{}] failed to save 锛侊紒锛�", insertSeg.getTravelId() + " - " + insertSeg.getSerial());
                 }
                 segmentList.add(insertSeg);
 
@@ -190,8 +264,11 @@
                         interrupt = true;
                     } else {
                         if (nextStep.getEndNode() == endNode) {
-
-                            segmentList.add(nextStep);
+                            // remove sta action seg
+                            if (!nextStep.getPosType().equals(TaskPosDto.PosType.ORI_STA.toString())
+                                    && !nextStep.getPosType().equals(TaskPosDto.PosType.DEST_STA.toString())) {
+                                segmentList.add(nextStep);
+                            }
                         } else {
                             interrupt = true;
                         }
@@ -202,7 +279,7 @@
 
             mapService.lockPath(null, pathList, agv.getUuid());
 
-            startTime = System.currentTimeMillis();
+//            startTime = System.currentTimeMillis();
             mainService.generateAction(segment.getAgvId(), segmentList, pathList, now);
 //            System.out.println("generateAction: " + (System.currentTimeMillis() - startTime));
 
@@ -210,6 +287,7 @@
             log.error("TrafficService.trigger", e);
             TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
 
+            throw new RuntimeException("trigger method caught an exception", e);
         }
     }
 
@@ -416,6 +494,7 @@
             // deal expired jam
             for (Jam expiredJam : jamService.list(new LambdaQueryWrapper<Jam>()
                     .eq(Jam::getJamAgv, agv.getId())
+                    .ne(Jam::getCycleAvo, 1)
                     .eq(Jam::getState, JamStateType.RUNNING.toString()))) {
                 expiredJam.setEndTime(now);
                 expiredJam.setUpdateTime(now);
@@ -593,7 +672,7 @@
 
                             // the wave of first node
                             Double avoidDistance = MapDataUtils.getVehicleWaveSafeDistance(
-                                    agvModelService.getById(jamAgv.getAgvModel()).getDiameter(),
+                                    agvModelService.getByAgvId(jamAgv.getAgvModel()).getDiameter(),
                                     MapDataConstant.MAX_DISTANCE_BETWEEN_ADJACENT_AGV_FACTOR
                             );
                             List<String> waveCodeList = mapService.getWaveScopeByCode(lev, firstCodeNode, avoidDistance)
@@ -618,8 +697,13 @@
             if (!blockVehicleDto.isAvoidable()) {
                 continue;
             }
+            Long agvId = agvService.getAgvId(blockVehicleDto.getVehicle());
             // 褰撳墠vehicle姝e湪杩涜閬胯浣滀笟
-            if (!Cools.isEmpty(jamService.getUnfinishedAvoSegByAvo(blockVehicleDto.getVehicle(), null))) {
+            if (!Cools.isEmpty(jamService.getUnfinishedAvoSegByAvo(agvId, null))) {
+                continue;
+            }
+            // 褰撳墠vehicle姝e湪杩涜婊氱瓛杈撻�佺嚎绛夊緟
+            if (segmentService.isRollerWaiting(agvId)) {
                 continue;
             }
             return blockVehicleDto.getVehicle();

--
Gitblit v1.9.1