From bb809ceda79f25ed58ef1e764ba7ffcae3254faa Mon Sep 17 00:00:00 2001
From: luxiaotao1123 <t1341870251@163.com>
Date: 星期三, 06 十一月 2024 14:05:34 +0800
Subject: [PATCH] #

---
 zy-acs-manager/src/main/java/com/zy/acs/manager/core/service/TrafficService.java |  236 +++++++++++++++++++++++++---------------------------------
 1 files changed, 101 insertions(+), 135 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 0325a9c..fe6f6da 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
@@ -11,7 +11,6 @@
 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;
@@ -23,7 +22,10 @@
 import org.springframework.transaction.annotation.Transactional;
 import org.springframework.transaction.interceptor.TransactionAspectSupport;
 
-import java.util.*;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Date;
+import java.util.List;
 import java.util.stream.Collectors;
 
 /**
@@ -36,7 +38,7 @@
 
     public static final Integer MIN_SLICE_PATH_LENGTH = 3;
 
-    public static final Integer timeoutDuration = 5 * 1000;
+    public static final Integer MAX_JAM_TIMEOUT = 5 * 1000;
 
     private final RedisSupport redis = RedisSupport.defaultRedisSupport;
 
@@ -69,9 +71,6 @@
     @Autowired
     private AvoidWaveCalculator avoidWaveCalculator;
 
-
-    // todo
-    //  1.鏁呴殰
     @Transactional
     public synchronized void trigger(Segment segment) {
         try {
@@ -216,10 +215,11 @@
             if (!Cools.isEmpty(pathList)) {
 
                 if (!pathList.get(pathList.size() - 1).equals(endCode.getData())) {
-
                     assert !Cools.isEmpty(blockVehicleList);
-                    if (blockVehicleList.stream().anyMatch(blockVehicleDto -> !blockVehicleDto.isAvoidable())
-                            && pathList.size() <= MIN_SLICE_PATH_LENGTH) {
+
+                    boolean hasUnavoidableBlocks  = blockVehicleList.stream().anyMatch(blockVehicleDto -> !blockVehicleDto.isAvoidable());
+                    if (hasUnavoidableBlocks && pathList.size() <= MIN_SLICE_PATH_LENGTH) {
+                        log.info("AGV[{}] waiting in place, because the path list is too short...", agvNo);
                         pathList.clear();
                     }
                 }
@@ -227,48 +227,76 @@
             // 鏃犲彲璧拌璺緞
             } else {
 
-                // 闃诲杞﹁締鍒楄〃
                 assert !Cools.isEmpty(blockVehicleList);
+                Integer maxJamTimeoutFactor = null;
 
-                String blockAgvNo = blockVehicleList.stream()
-                        .filter(BlockVehicleDto::isAvoidable)
-                        .map(BlockVehicleDto::getVehicle)
-                        .findFirst().orElse(null);
-                // 濡傛灉鍏ㄦ槸杩愯涓殑闃诲agv锛屽垯涓嶈繘琛岄伩璁╅�昏緫  todo
-                if (Cools.isEmpty(blockAgvNo)) {
-                    return pathList;
-                }
+                // persist jam data
+                jam = this.createOrUpdateJam(agv, startCode, segment, jam);
 
-                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;
-                    }
+                // ? has unAvoidable block vehicles
+                if (blockVehicleList.stream().anyMatch(blockVehicleDto -> !blockVehicleDto.isAvoidable())) {
+
+                    // set factor of jam timeout
+                    maxJamTimeoutFactor = 1;
                 } else {
-                    jam.setDuration(System.currentTimeMillis() - jam.getStartTime().getTime());
-                    if (!jamService.updateById(jam)) {
-                        log.error("{}缂栧彿闃诲璁板綍鏇存柊澶辫触锛侊紒锛�", jam.getUuid());
+
+                    // ? already do notify to avoid
+                    if (!Cools.isEmpty(jam.getAvoAgv())
+                            && BlockVehicleDto.customContain(blockVehicleList, agvService.getById(jam.getAvoAgv()).getUuid())) {
+
+                        maxJamTimeoutFactor = 10;
+
+                    } else {
+
+                        // select optimal block vehicle
+                        String blockAgvNo = blockVehicleList.stream()
+                                .filter(BlockVehicleDto::isAvoidable)
+                                .map(BlockVehicleDto::getVehicle)
+                                .findFirst().orElse(null);
+
+                        // block vehicle info
+                        Agv blockAgv = agvService.selectByUuid(blockAgvNo);
+                        String blockAgvCode = codeService.getById(agvDetailService.selectByAgvId(blockAgv.getId()).getRecentCode()).getData();
+
+                        do {
+
+                            // 闃诲杞﹁締姝e湪鍘熷湴浣滀笟锛岀瓑寰� ===>> 瓒呰繃绛夊緟鏃堕棿锛岀粫璺�
+                            List<Segment> runningSegList = segmentService.getByAgvAndState(blockAgv.getId(), SegmentStateType.RUNNING.toString());
+                            if (!Cools.isEmpty(runningSegList)) {
+                                maxJamTimeoutFactor = 1;
+                                break;
+                            }
+
+                            // 鍒ゆ柇涓嬩釜浠诲姟鏄惁涓哄師鍦颁换鍔★紝濡傛灉鏄垯绛夊緟 ===>> 瓒呰繃绛夊緟鏃堕棿锛岀粫璺紱濡傛灉涓嶆槸锛岃闃诲杞﹁締閬胯
+                            Segment waitingSeg = segmentService.getJustWaitingSeg(blockAgv.getId());
+                            if (null != waitingSeg && waitingSeg.getEndNode().equals(codeService.selectByData(blockAgvCode).getId())) {
+                                maxJamTimeoutFactor = 1;
+                                break;
+                            }
+
+                            // notify block vehicle to avoid
+                            if (this.notifyVehicleAvoid(blockAgvNo, blockAgvCode, unlockPathList, agvNo, jam)) {
+                                if (jam.getCycleAvo() == 1) {
+                                    jam.setCycleCode(endCode.getId());
+                                }
+                                jam.setAvoAgv(blockAgv.getId());
+                                jam.setNotifyTime(new Date());
+                                if (!jamService.updateById(jam)) {
+                                    throw new CoolException(jam.getUuid() + "-jam failed to update锛侊紒锛�");
+                                }
+                            } else {
+
+                                maxJamTimeoutFactor = 1;
+                            }
+
+                        } while (false);
                     }
+
                 }
-                long previousTimestamp = jam.getStartTime().getTime();
 
-                // jam vehicle info
-                Agv blockAgv = agvService.selectByUuid(blockAgvNo);
-                String blockAgvCode = codeService.getById(agvDetailService.selectByAgvId(blockAgv.getId()).getRecentCode()).getData();
-
-                // jam vehicle dynamic on map matrix
-                List<String> blockDynamicList = mapDataDispatcher.queryCodeListFromDynamicNode(lev, blockAgvNo);
-
-                // 璺緞闃诲
-                if (blockDynamicList.size() > 1) {
-                    if (System.currentTimeMillis() - previousTimestamp > timeoutDuration) {
+                // handle jam timeout
+                if (null != maxJamTimeoutFactor) {
+                    if (System.currentTimeMillis() - jam.getStartTime().getTime() > MAX_JAM_TIMEOUT * maxJamTimeoutFactor) {
 
                         if (!Cools.isEmpty(lockPathList)) {
 
@@ -278,95 +306,11 @@
                                     , agvNo, startCode.getData(), endCode.getData(), "璺緞闃诲瓒呮椂");
                         }
                     } else {
-                        log.info("{}鍙疯溅杈嗘鍦ㄧ瓑寰呬氦閫氬牭濉烇紝闃诲杞﹁締锛氥�恵}銆�", agvNo, blockAgvNo);
+                        log.warn("{}鍙疯溅杈嗘鍦ㄧ瓑寰呬氦閫氬牭濉烇紝闃诲杞﹁締锛氥�恵}銆�"
+                                , agvNo
+                                , blockVehicleList.stream().map(BlockVehicleDto::getVehicle).collect(Collectors.toList()).toString()
+                        );
                     }
-
-                // 杞﹁締闃诲
-                } 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 {
-
-                        // 闃诲杞﹁締姝e湪浣滀笟锛岀瓑寰� ===>> 瓒呰繃绛夊緟鏃堕棿锛岀粫璺�
-                        List<Segment> runningSegList = segmentService.getByAgvAndState(blockAgv.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, blockAgvNo);
-                            }
-
-                            break;
-                        }
-
-                        // 鍒ゆ柇涓嬩釜浠诲姟鏄惁涓哄師鍦颁换鍔★紝濡傛灉鏄垯绛夊緟 ===>> 瓒呰繃绛夊緟鏃堕棿锛岀粫璺紱濡傛灉涓嶆槸锛岃闃诲杞﹁締閬胯
-                        Segment waitingSeg = segmentService.getJustWaitingSeg(blockAgv.getId());
-                        if (null != waitingSeg) {
-
-                            // 濡傛灉闃诲杞﹁締寰呮墽琛屼换鍔″浜庡師鍦帮紝鍒欎笉鑳介�氱煡瀹冮伩璁�
-                            if (waitingSeg.getEndNode().equals(codeService.selectByData(blockAgvCode).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, blockAgvNo);
-                                }
-
-                                break;
-                            }
-                        }
-
-                        // 閫氱煡闃诲杞﹁締閬胯
-                        if (this.notifyVehicleAvoid(blockAgvNo, blockAgvCode, unlockPathList, agvNo, jam)) {
-
-                            if (jam.getCycleAvo() == 1) {
-                                jam.setCycleCode(endCode.getId());
-                            }
-                            jam.setAvoAgv(blockAgv.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, blockAgvNo);
-                            }
-                        }
-
-                    } while (false);
-
                 }
 
             }
@@ -380,7 +324,7 @@
                 jam.setUpdateTime(now);
                 jam.setState(JamStateType.FINISH.toString());
                 if (!jamService.updateById(jam)) {
-                    log.error("{}缂栧彿闃诲璁板綍瀹屾垚淇敼澶辫触锛侊紒锛�", jam.getUuid());
+                    log.error("Jam[{}] failed to update锛侊紒锛�", jam.getUuid());
                 }
             }
             // deal expired jam
@@ -391,7 +335,7 @@
                 expiredJam.setUpdateTime(now);
                 expiredJam.setState(JamStateType.FINISH.toString());
                 if (!jamService.updateById(expiredJam)) {
-                    log.error("{}缂栧彿闃诲璁板綍瀹屾垚淇敼澶辫触锛侊紒锛�", expiredJam.getUuid());
+                    log.error("Jam[{}] failed to update锛侊紒锛�", expiredJam.getUuid());
                 }
             }
 
@@ -403,7 +347,7 @@
     private List<BlockVehicleDto> slicePathAndReturnBlockVehicleList(Integer lev, List<String> fullPathList, String agvNo, List<String> pathList) {
         List<BlockVehicleDto> blockVehicleList = new ArrayList<>();
 
-        DynamicNode[][] dynamicMatrix = mapDataDispatcher.getDynamicMatrix(lev);
+//        DynamicNode[][] dynamicMatrix = mapDataDispatcher.getDynamicMatrix(lev);
         String[][] waveMatrix = mapDataDispatcher.getWaveMatrix(lev);
         for (String code : fullPathList) {
             int[] node = mapDataDispatcher.getCodeMatrixIdx(lev, code);
@@ -503,4 +447,26 @@
         return true;
     }
 
+    private Jam createOrUpdateJam(Agv agv, Code startCode, Segment segment, Jam jam) {
+        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.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;
+    }
+
 }

--
Gitblit v1.9.1