From 69ba128c58bfb9f5a79481e4997558aafc6f46c6 Mon Sep 17 00:00:00 2001
From: zjj <3272660260@qq.com>
Date: 星期二, 23 九月 2025 15:21:51 +0800
Subject: [PATCH] #

---
 src/main/java/com/zy/core/action/ShuttleAction.java |  623 +++++++++++---------------------------------------------
 1 files changed, 124 insertions(+), 499 deletions(-)

diff --git a/src/main/java/com/zy/core/action/ShuttleAction.java b/src/main/java/com/zy/core/action/ShuttleAction.java
index a0a88b1..a44e675 100644
--- a/src/main/java/com/zy/core/action/ShuttleAction.java
+++ b/src/main/java/com/zy/core/action/ShuttleAction.java
@@ -119,9 +119,11 @@
             return false;
         }
 
+        News.info("[RCS Debug] Execute check command {},{}", shuttleNo, taskNo);
         //妫�娴嬪懡浠�
-        int checked = checkCommand(redisCommand, shuttleNo);
-        if (checked == 0) {
+        ShuttleCheckCommandResultType checked = checkCommand(redisCommand, shuttleNo);
+        News.info("[RCS Debug] Execute check command complete {},{}", shuttleNo, taskNo);
+        if (checked.equals(ShuttleCheckCommandResultType.FAIL)) {
             return false;
         }
 
@@ -138,7 +140,7 @@
 
         //鍙栧嚭鍛戒护
         ShuttleCommand command = null;
-        if (checked == 1) {
+        if (checked.equals(ShuttleCheckCommandResultType.SUCCESS)) {
             //闈炶繛缁寚浠わ紝闇�瑕佹娴嬩笂涓�鏉℃寚浠ゆ槸鍚﹀畬鎴�
             if (commandStep > 0) {
                 ShuttleCommand lastCommand = commands.get(commandStep - 1);
@@ -148,7 +150,7 @@
             }
 
             command = commands.get(commandStep);
-        } else if (checked == 2) {
+        } else if (checked.equals(ShuttleCheckCommandResultType.SUCCESS_GO)) {
             //杩炵画鎸囦护鐩存帴鍙栨暟鎹�
             command = commands.get(commandStep);
         }
@@ -165,20 +167,25 @@
             }
 
             List<NavigateNode> nodes = JSON.parseArray(JSON.toJSONString(command.getNodes()), NavigateNode.class);
-            //鐢宠绠″埗
-            applyTrafficControl(commands, nodes, shuttleNo, taskNo);
+
+            Object object = redisUtil.get(RedisKeyType.TRAFFIC_CONTROL_LOCK_APPLY.key + shuttleNo);
+            if (object == null) {
+                //鐢宠绠″埗
+                News.info("[RCS Debug] Execute apply control {},{}", shuttleNo, taskNo);
+                redisUtil.set(RedisKeyType.TRAFFIC_CONTROL_LOCK_APPLY.key + shuttleNo, "lock", 10);
+                applyTrafficControl(commands, nodes, shuttleNo, taskNo);
+                News.info("[RCS Debug] Execute apply control complete {},{}", shuttleNo, taskNo);
+            }
+
+            News.info("[RCS Debug] Execute query control {},{}", shuttleNo, taskNo);
             //鏌ヨ绠″埗
             boolean apply = queryTrafficControl(shuttleNo, taskNo);
+            News.info("[RCS Debug] Execute query control complete {},{}", shuttleNo, taskNo);
             if(!apply){
                 return false;//鐢宠澶辫触
             }
-//            //妫�娴嬭矾寰勬槸鍚﹀啿绐�
-//            int conflict = searchShuttlePathConflict(nodes, shuttleNo);
-//            if(conflict == 2){
-//                return false;//妫�娴嬪悗鏈夊啿绐�
-//            }
 
-            if (checked == 2) {
+            if (checked.equals(ShuttleCheckCommandResultType.SUCCESS_GO)) {
                 nodes.remove(0);
             }
 
@@ -191,8 +198,10 @@
             }
         }
 
+        News.info("[RCS Debug] Execute send command {},{}", shuttleNo, taskNo);
         // 涓嬪彂鍛戒护
         CommandResponse response = write(command, shuttleNo);
+        News.info("[RCS Debug] Execute send command complete {},{}", shuttleNo, taskNo);
 
         //淇濆瓨鍛戒护鏃ュ織
         BasShuttleOpt basShuttleOpt = new BasShuttleOpt();
@@ -231,38 +240,40 @@
      * 妫�娴嬪懡浠�
      * 0:鏈�氳繃 1:閫氳繃 2:閫氳繃涓斿彲鎻愬墠涓嬪彂鎸囦护
      */
-    private int checkCommand(ShuttleRedisCommand redisCommand, Integer shuttleNo) {
+    private ShuttleCheckCommandResultType checkCommand(ShuttleRedisCommand redisCommand, Integer shuttleNo) {
         TrafficControlThread trafficControlThread = (TrafficControlThread) SlaveConnection.get(SlaveType.TrafficControl, 1);
         if(trafficControlThread == null){
-            return 0;
+            return ShuttleCheckCommandResultType.FAIL;
         }
 
         ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, shuttleNo);
         if (shuttleThread == null) {
-            return 0;
+            return ShuttleCheckCommandResultType.FAIL;
         }
 
         ShuttleProtocol shuttleProtocol = shuttleThread.getStatus();
         if (shuttleProtocol == null) {
-            return 0;
+            return ShuttleCheckCommandResultType.FAIL;
         }
 
         int commandStep = redisCommand.getCommandStep();
         if (commandStep == 0) {
-            return 1;//绗竴鏉″懡浠ゆ棤闇�妫�娴�
+            return ShuttleCheckCommandResultType.SUCCESS;//绗竴鏉″懡浠ゆ棤闇�妫�娴�
         }
 
         ShuttleAssignCommand assignCommand = redisCommand.getAssignCommand();
         List<ShuttleCommand> commands = assignCommand.getCommands();
         if (commands.isEmpty()) {
-            return 0;
+            return ShuttleCheckCommandResultType.FAIL;
         }
 
         boolean supportContinuously = false;
         int checkIdx = commandStep - 2;
         if (checkIdx < 0) {
+            supportContinuously = true;
             checkIdx = commandStep - 1;
         }
+
         ShuttleCommand last2Command = commands.get(checkIdx);
         if(last2Command.getComplete()){
             supportContinuously = true;
@@ -280,18 +291,18 @@
                 //灏忚溅绉诲姩杩炵画涓嬪彂鎸囦护
                 if (assignCommand.getShuttleMoveCommandsContinuously()) {
                     if (!supportContinuously) {
-                        return 0;
+                        return ShuttleCheckCommandResultType.FAIL;
                     }
 
                     //绉诲姩鎸囦护
                     if(lastCommand.getMode() != ShuttleCommandModeType.MOVE.id) {
-                        return 0;
+                        return ShuttleCheckCommandResultType.FAIL;
                     }
 
                     List<NavigateNode> nodes = lastCommand.getNodes();
                     NavigateNode startNode = nodes.get(0);
                     if (!startNode.getLinePartAllowGo()) {//鐩寸嚎娈甸儴鍒嗭紝鍏佽鐩存帴琛岃蛋
-                        return 0;
+                        return ShuttleCheckCommandResultType.FAIL;
                     }
 
                     //鐩寸嚎娈垫暟鎹爣璇�
@@ -301,23 +312,23 @@
                         //鍙栨寚浠�
                         ShuttleCommand currentCommand = commands.get(commandStep);
                         if(currentCommand.getMode() != ShuttleCommandModeType.MOVE.id) {
-                            return 0;
+                            return ShuttleCheckCommandResultType.FAIL;
                         }
 
                         List<NavigateNode> currentNodes = currentCommand.getNodes();
                         NavigateNode currentStartNode = currentNodes.get(0);
                         if(!currentStartNode.getLinePartAllowGo()) {//鐩寸嚎娈甸儴鍒嗭紝鍏佽鐩存帴琛岃蛋
-                            return 0;
+                            return ShuttleCheckCommandResultType.FAIL;
                         }
 
                         if(currentStartNode.getLinePartFlag().equals(linePartFlag)) {
                             //鏁版嵁鏍囪瘑涓�鑷�
-                            return 2;//鍏佽灏忚溅绉诲姩杩炵画涓嬪彂鎸囦护
+                            return ShuttleCheckCommandResultType.SUCCESS_GO;//鍏佽灏忚溅绉诲姩杩炵画涓嬪彂鎸囦护
                         }
                     }
                 }
 
-                return 0;
+                return ShuttleCheckCommandResultType.FAIL;
             }
         }
 
@@ -328,16 +339,24 @@
 
             // 绯荤粺浠诲姟
             if (assignCommand.getAuto()) {
-                if (!assignCommand.getCharge()) {
-                    //瀵逛富绾跨▼鎶涘嚭绛夊緟纭鐘舵�亀aiting
-                    shuttleThread.setProtocolStatus(ShuttleProtocolStatusType.WAITING);
-                } else {
-                    shuttleThread.setProtocolStatus(ShuttleProtocolStatusType.CHARGING_WAITING);
+                if (assignCommand.getTaskMode() == ShuttleTaskModeType.UPDATE_LOCATION.id) {//鏇存柊鍧愭爣鏃犻渶绛夊緟纭
+                    //鐩存帴澶嶄綅绌洪棽鐘舵��
+                    shuttleThread.setProtocolStatus(ShuttleProtocolStatusType.IDLE);
+                    //浠诲姟鍙锋竻闆�
+                    shuttleThread.setSyncTaskNo(0);
+                    //鏍囪澶嶄綅
+                    shuttleThread.setPakMk(true);
+                    News.info("鍥涘悜绌挎杞︽洿鏂板潗鏍囦换鍔℃墽琛屽畬鎴愶紝绌挎杞﹀彿={}锛屼换鍔℃暟鎹�={}", shuttleProtocol.getShuttleNo(), JSON.toJSON(endCommand));
+                }else {
+                    if (!assignCommand.getCharge()) {
+                        //瀵逛富绾跨▼鎶涘嚭绛夊緟纭鐘舵�亀aiting
+                        shuttleThread.setProtocolStatus(ShuttleProtocolStatusType.WAITING);
+                    } else {
+                        shuttleThread.setProtocolStatus(ShuttleProtocolStatusType.CHARGING_WAITING);
+                    }
+                    News.info("鍥涘悜绌挎杞︿换鍔℃墽琛屼笅鍙戝畬鎴愮瓑寰呮墽琛岀粨鏉燂紝绌挎杞﹀彿={}锛屼换鍔℃暟鎹�={}", shuttleProtocol.getShuttleNo(), JSON.toJSON(endCommand));
                 }
-                News.info("鍥涘悜绌挎杞︿换鍔℃墽琛屼笅鍙戝畬鎴愮瓑寰呮墽琛岀粨鏉燂紝绌挎杞﹀彿={}锛屼换鍔℃暟鎹�={}", shuttleProtocol.getShuttleNo(), JSON.toJSON(endCommand));
-
-                // 鎵嬪姩浠诲姟
-            } else {
+            } else {// 鎵嬪姩浠诲姟
                 //鎵嬪姩妯″紡涓嶆姏鍑虹瓑寰呯姸鎬侊紝鐩存帴澶嶄綅绌洪棽鐘舵��
                 shuttleThread.setProtocolStatus(ShuttleProtocolStatusType.IDLE);
                 //浠诲姟鍙锋竻闆�
@@ -348,13 +367,14 @@
             }
 
             //鐢宠鍙栨秷绠″埗
-            trafficControlThread.cancelTrafficControl(shuttleNo, shuttleProtocol.getTaskNo());
+            cancelTrafficControl(shuttleNo, shuttleProtocol.getTaskNo());
+
             //鍒犻櫎redis
             redisUtil.del(RedisKeyType.SHUTTLE_WORK_FLAG.key + redisCommand.getWrkNo());
-            return 0;//绂佹鍐嶄笅鍙戝懡浠�
+            return ShuttleCheckCommandResultType.FAIL;//绂佹鍐嶄笅鍙戝懡浠�
         }
 
-        return 1;
+        return ShuttleCheckCommandResultType.SUCCESS;
     }
 
     //妫�娴嬫洿鏂板懡浠ゅ畬鎴�
@@ -415,7 +435,9 @@
                 return false;
             }
             //涓婃姤浜ょ
+            News.info("[RCS Debug] Execute check command report traffic {},{}", shuttleNo, shuttleProtocol.getTaskNo());
             trafficControlThread.trafficReport(command.getNodesDeepCopy(), shuttleNo, shuttleProtocol.getTaskNo());
+            News.info("[RCS Debug] Execute check command report traffic complete {},{}", shuttleNo, shuttleProtocol.getTaskNo());
 
             String currentLocNo = shuttleProtocol.getCurrentLocNo();
             if (currentLocNo == null) {
@@ -497,103 +519,20 @@
 
     //鏌ヨ鏄惁鐢宠绠″埗鎴愬姛
     public boolean queryTrafficControl(Integer shuttleNo, Integer taskNo) {
-        TrafficControlThread trafficControlThread = (TrafficControlThread) SlaveConnection.get(SlaveType.TrafficControl, 1);
-        if (trafficControlThread == null) {
+        Object object = redisUtil.get(RedisKeyType.TRAFFIC_CONTROL_SUCCESS_APPLY.key + shuttleNo + "_" + taskNo);
+        if (object == null) {
             return false;
         }
-
-        TrafficControlDataModel trafficControlDataModel = trafficControlThread.queryTrafficControl(shuttleNo, taskNo);
-        if (trafficControlDataModel == null) {
-            return false;
-        }
-
         return true;
     }
 
-//    /**
-//     * 鎼滅储灏忚溅璺緞鏄惁瀛樺湪鍐茬獊
-//     * 0:鏈娴� 1:妫�娴嬫棤鍐茬獊 2:妫�娴嬫湁鍐茬獊
-//     */
-//    public int searchShuttlePathConflict(List<NavigateNode> nodeList, Integer shuttleNo) {
-//        ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, shuttleNo);
-//        if (shuttleThread == null) {
-//            return 0;
-//        }
-//
-//        ShuttleProtocol shuttleProtocol = shuttleThread.getStatus();
-//        if (shuttleProtocol == null) {
-//            return 0;
-//        }
-//
-//        int lev = Utils.getLev(shuttleProtocol.getCurrentLocNo());
-//
-//        TrafficControlThread trafficControlThread = (TrafficControlThread) SlaveConnection.get(SlaveType.TrafficControl, 1);
-//        if (trafficControlThread == null) {
-//            return 2;
-//        }
-//        HashMap<String, List<Integer>> nodeMap = trafficControlThread.getNodesMapByLev(lev);
-//        if (nodeMap == null || nodeMap.isEmpty()) {
-//            return 2;
-//        }
-//
-//        List<String> conflictLocList = new ArrayList<>();
-//        for (NavigateNode node : nodeList) {
-//            String locNo = Utils.getLocNo(node.getX(), node.getY(), lev);
-//            if(!nodeMap.containsKey(locNo)) {
-//                return 2;
-//            }
-//
-//            List<Integer> shuttleNos = nodeMap.get(locNo);
-//            if (shuttleNos.size() > 1) {
-//                //璺緞瀛樺湪澶氳溅锛屽啿绐�
-//                conflictLocList.add(locNo);
-//            }
-//        }
-//
-//        if (conflictLocList.isEmpty()) {
-//            //鏃犲啿绐侊紝瑙i櫎浜ら�氱鍒�
-//            shuttleThread.setTrafficControl(false, null);
-//            return 1;//妫�娴嬪悗鏃犲啿绐�
-//        }
-//
-//        //璺緞瀛樺湪鍐茬獊锛屾娴嬪彲鎵ц杞﹁締鏄惁涓哄綋鍓嶅皬杞�
-//        //涓婃姤灏忚溅鐘舵��-浜ら�氱鍒朵腑
-//        shuttleThread.setTrafficControl(true, nodeList);
-//
-//        HashMap<String, Integer> deviceMap = trafficControlThread.getDeviceMap();
-//        if(deviceMap == null) {
-//            return 2;
-//        }
-//
-//        boolean detected = false;
-////            for (Map.Entry<String, Integer> entry : deviceMap.entrySet()) {
-////                List<String> mainList = JSON.parseArray(entry.getKey(), String.class);
-////                Integer device = entry.getValue();
-////                if(result) {
-////                    //鍒ゆ柇绠″埗杞﹁締鏄惁鍖归厤
-////                    if(shuttleNo.equals(device)) {
-////                        detected = true;
-////                        break;
-////                    }
-////                }
-////            }
-//
-//        for (Map.Entry<String, Integer> entry : deviceMap.entrySet()) {
-//            String key = entry.getKey();
-//            Integer value = entry.getValue();
-//            if(shuttleNo.equals(value)) {
-//                //鍒ゆ柇绠″埗杞﹁締鏄惁鍖归厤
-//                detected = true;
-//                break;
-//            }
-//        }
-//
-//        if (detected) {
-//            return 1;//妫�娴嬪悗鏃犲啿绐侊紝浜ら�氱鍒跺凡鍏佽姝ゅ皬杞﹁繍琛�
-//        }
-//
-//        return 2;//妫�娴嬪悗鏈夊啿绐�
-//    }
+    public boolean cancelTrafficControl(Integer shuttleNo, Integer taskNo) {
+        TrafficControlDataModel model = new TrafficControlDataModel();
+        model.setShuttleNo(shuttleNo);
+        model.setTaskNo(taskNo);
+        redisUtil.set(RedisKeyType.TRAFFIC_CONTROL_CANCEL_LIST.key + shuttleNo + "_" + taskNo, model);
+        return true;
+    }
 
     //婕旂ず妯″紡
     public synchronized void demo(Integer shuttleNo) {
@@ -626,7 +565,7 @@
             return;
         }
 
-        if (shuttleThread.isRequireCharge()) {
+        if (!shuttleThread.isRequireCharge().equals(ShuttleRequireChargeType.NONE)) {
             return;
         }
 
@@ -768,376 +707,62 @@
         }
     }
 
-//    //璺戝簱绋嬪簭
-//    public synchronized void moveLoc(Integer shuttleNo) {
-//        ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, shuttleNo);
-//        if (shuttleThread == null) {
-//            return;
-//        }
-//        ShuttleProtocol shuttleProtocol = shuttleThread.getStatus(false);
-//        if (shuttleProtocol == null) {
-//            return;
-//        }
-//
-//        //灏忚溅寮�鍚窇搴撴ā寮�
-//        if (!shuttleProtocol.getMoveLoc()) {
-//            return;
-//        }
-//
-//        //灏忚溅绌洪棽
-//        if (!shuttleThread.isIdle()) {
-//            return;
-//        }
-//
-//        int lev = Utils.getLev(shuttleProtocol.getCurrentLocNo());//灏忚溅褰撳墠妤煎眰
-//
-//        if (shuttleProtocol.getMoveType() == 0) {//璺戣建閬�
-//            //鏍规嵁鍦板浘鏂瑰悜鍐冲畾璺憍鎴杫
-//            Config config = configService.selectOne(new EntityWrapper<Config>()
-//                    .eq("code", "direction_map")
-//                    .eq("status", 1));
-//            if (config == null) {
-//                //璺戝簱缁撴潫
-//                shuttleProtocol.setMoveLoc(false);
-//                shuttleProtocol.setMoveType(0);
-//                shuttleProtocol.setXStart(0);
-//                shuttleProtocol.setXTarget(0);
-//                shuttleProtocol.setXCurrent(0);
-//                shuttleProtocol.setYStart(0);
-//                shuttleProtocol.setYTarget(0);
-//                shuttleProtocol.setYCurrent(0);
-//                return;
-//            }
-//            String direction = config.getValue();
-//
-//            if (direction.equals("y")) {//璺憍杞存柟鍚戯紝璺戝畬x杞村啀鍒囨崲y杞�
-//                ArrayList<String> locs = new ArrayList<>();
-//                for (int i = shuttleProtocol.getXCurrent(); i <= shuttleProtocol.getXTarget(); i++) {
-//                    String locNo = Utils.getLocNo(i, shuttleProtocol.getYCurrent(), lev);
-//                    locs.add(locNo);
-//                }
-//
-//                List<LocMast> locList = locMastService.selectList(new EntityWrapper<LocMast>()
-//                        .eq("loc_sts", LocStsType.O.toString())
-//                        .in("loc_no", locs));
-//                if (locList.isEmpty()) {
-//                    //绌哄簱浣�
-//                    shuttleProtocol.setYCurrent(shuttleProtocol.getYCurrent() + 1);
-//                    return;
-//                }
-//
-//                LocMast start = locList.get(0);
-//                LocMast target = locList.get(locList.size() - 1);
-//                //鍒ゆ柇灏忚溅鏄惁鍦ㄨ捣鐐逛綅缃�
-//                if (!shuttleProtocol.getCurrentLocNo().equals(start.getLocNo())) {//涓嶅湪璧风偣浣嶇疆锛岃皟搴﹀幓璧风偣浣嶇疆
-//                    shuttleDispatcher.generateMoveTask(device, start.getLocNo());
-//                }else {
-//                    //鍦ㄨ捣鐐逛綅缃紝璋冨害鍘荤洰鏍囦綅缃�
-//                    Task task = shuttleDispatcher.generateMoveTask(device, target.getLocNo());
-//                    if (task != null) {
-//                        shuttleProtocol.setYCurrent(shuttleProtocol.getYCurrent() + 1);//鍒囨崲y杞�
-//                    }
-//
-//                    if(shuttleProtocol.getYCurrent() > shuttleProtocol.getYTarget()) {
-//                        //y杞翠篃璺戝畬浜嗭紝缁撴潫璺戝簱
-//                        shuttleProtocol.setMoveLoc(false);
-//                        shuttleProtocol.setMoveType(0);
-//                        shuttleProtocol.setXStart(0);
-//                        shuttleProtocol.setXTarget(0);
-//                        shuttleProtocol.setXCurrent(0);
-//                        shuttleProtocol.setYStart(0);
-//                        shuttleProtocol.setYTarget(0);
-//                        shuttleProtocol.setYCurrent(0);
-//                        return;
-//                    }
-//                }
-//            }else {//璺憏杞存柟鍚戯紝璺戝畬y杞村啀鍒囨崲x杞�
-//                ArrayList<String> locs = new ArrayList<>();
-//                for (int i = shuttleProtocol.getYCurrent(); i <= shuttleProtocol.getYTarget(); i++) {
-//                    String locNo = Utils.getLocNo(shuttleProtocol.getXCurrent(), i, lev);
-//                    locs.add(locNo);
-//                }
-//
-//                List<Loc> locList = locService.list(new LambdaQueryWrapper<Loc>()
-//                        .eq(Loc::getLocSts, LocStsType.O.val())
-//                        .in(Loc::getLocNo, locs));
-//                if (locList.isEmpty()) {
-//                    //绌哄簱浣�
-//                    shuttleProtocol.setXCurrent(shuttleProtocol.getXCurrent() + 1);
-//                    return;
-//                }
-//
-//                Loc start = locList.get(0);
-//                Loc target = locList.get(locList.size() - 1);
-//                //鍒ゆ柇灏忚溅鏄惁鍦ㄨ捣鐐逛綅缃�
-//                if (!shuttleProtocol.getCurrentLocNo().equals(start.getLocNo())) {//涓嶅湪璧风偣浣嶇疆锛岃皟搴﹀幓璧风偣浣嶇疆
-//                    shuttleDispatcher.generateMoveTask(device, start.getLocNo());
-//                }else {
-//                    //鍦ㄨ捣鐐逛綅缃紝璋冨害鍘荤洰鏍囦綅缃�
-//                    Task task = shuttleDispatcher.generateMoveTask(device, target.getLocNo());
-//                    if (task != null) {
-//                        shuttleProtocol.setXCurrent(shuttleProtocol.getXCurrent() + 1);//鍒囨崲x杞�
-//                    }
-//
-//                    if(shuttleProtocol.getXCurrent() > shuttleProtocol.getXTarget()) {
-//                        //y杞翠篃璺戝畬浜嗭紝缁撴潫璺戝簱
-//                        shuttleProtocol.setMoveLoc(false);
-//                        shuttleProtocol.setMoveType(0);
-//                        shuttleProtocol.setXStart(0);
-//                        shuttleProtocol.setXTarget(0);
-//                        shuttleProtocol.setXCurrent(0);
-//                        shuttleProtocol.setYStart(0);
-//                        shuttleProtocol.setYTarget(0);
-//                        shuttleProtocol.setYCurrent(0);
-//                        return;
-//                    }
-//                }
-//            }
-//
-//        } else if (shuttleProtocol.getMoveType() == 1) {//璺戝簱浣�
-//            //鏍规嵁鍦板浘鏂瑰悜鍐冲畾璺憍鎴杫
-//            Dict dict = dictService.getOne(new LambdaQueryWrapper<Dict>()
-//                    .eq(Dict::getFlag, "direction_map")
-//                    .eq(Dict::getStatus, 1));
-//            if (dict == null) {
-//                //璺戝簱缁撴潫
-//                shuttleProtocol.setMoveLoc(false);
-//                shuttleProtocol.setMoveType(0);
-//                shuttleProtocol.setXStart(0);
-//                shuttleProtocol.setXTarget(0);
-//                shuttleProtocol.setXCurrent(0);
-//                shuttleProtocol.setYStart(0);
-//                shuttleProtocol.setYTarget(0);
-//                shuttleProtocol.setYCurrent(0);
-//                return;
-//            }
-//            String direction = dict.getValue();
-//
-//            if (direction.equals("y")) {//璺憍杞存柟鍚戯紝璺戝畬x杞村啀鍒囨崲y杞�
-//                Integer xCurrent = shuttleProtocol.getXCurrent();
-//
-//                //鑾峰彇寰呰窇搴撲綅鍙�
-//                String locNo = Utils.getLocNo(xCurrent, shuttleProtocol.getYCurrent(), lev);
-//                Loc target = locService.getOne(new LambdaQueryWrapper<Loc>()
-//                        .eq(Loc::getLocNo, locNo)
-//                        .eq(Loc::getLocSts, LocStsType.O.val())
-//                        .eq(Loc::getHostId, device.getHostId()));
-//                if (target == null || shuttleProtocol.getCurrentLocNo().equals(locNo)) {//搴撲綅涓嶅瓨鍦ㄦ垨灏忚溅宸插湪褰撳墠浣嶇疆
-//                    shuttleProtocol.setXCurrent(xCurrent + 1);
-//                    if (shuttleProtocol.getXCurrent() > shuttleProtocol.getXTarget()) {
-//                        //x杞磋窇瀹岋紝鍒囨崲y杞�
-//                        shuttleProtocol.setXCurrent(shuttleProtocol.getXStart());
-//                        shuttleProtocol.setYCurrent(shuttleProtocol.getYCurrent() + 1);
-//
-//                        if(shuttleProtocol.getYCurrent() > shuttleProtocol.getYTarget()) {
-//                            //y杞翠篃璺戝畬浜嗭紝缁撴潫璺戝簱
-//                            shuttleProtocol.setMoveLoc(false);
-//                            shuttleProtocol.setMoveType(0);
-//                            shuttleProtocol.setXStart(0);
-//                            shuttleProtocol.setXTarget(0);
-//                            shuttleProtocol.setXCurrent(0);
-//                            shuttleProtocol.setYStart(0);
-//                            shuttleProtocol.setYTarget(0);
-//                            shuttleProtocol.setYCurrent(0);
-//                            return;
-//                        }
-//                    }
-//                    return;
-//                }
-//
-//                //璋冨害鍘诲簱浣�
-//                Task task = shuttleDispatcher.generateMoveTask(device, locNo);
-//                if (task == null) {
-//                    return;//璋冨害澶辫触
-//                }
-//
-//                shuttleProtocol.setXCurrent(xCurrent + 1);
-//                if (shuttleProtocol.getXCurrent() > shuttleProtocol.getXTarget()) {
-//                    //x杞磋窇瀹岋紝鍒囨崲y杞�
-//                    shuttleProtocol.setXCurrent(shuttleProtocol.getXStart());
-//                    shuttleProtocol.setYCurrent(shuttleProtocol.getYCurrent() + 1);
-//
-//                    if(shuttleProtocol.getYCurrent() > shuttleProtocol.getYTarget()) {
-//                        //y杞翠篃璺戝畬浜嗭紝缁撴潫璺戝簱
-//                        shuttleProtocol.setMoveLoc(false);
-//                        shuttleProtocol.setMoveType(0);
-//                        shuttleProtocol.setXStart(0);
-//                        shuttleProtocol.setXTarget(0);
-//                        shuttleProtocol.setXCurrent(0);
-//                        shuttleProtocol.setYStart(0);
-//                        shuttleProtocol.setYTarget(0);
-//                        shuttleProtocol.setYCurrent(0);
-//                        return;
-//                    }
-//                }
-//
-//            }else {//璺憏杞存柟鍚戯紝璺戝畬y杞村啀鍒囨崲x杞�
-//                Integer yCurrent = shuttleProtocol.getYCurrent();
-//
-//                //鑾峰彇寰呰窇搴撲綅鍙�
-//                String locNo = Utils.getLocNo(shuttleProtocol.getXCurrent(), yCurrent, lev);
-//                Loc target = locService.getOne(new LambdaQueryWrapper<Loc>()
-//                        .eq(Loc::getLocNo, locNo)
-//                        .eq(Loc::getLocSts, LocStsType.O.val())
-//                        .eq(Loc::getHostId, device.getHostId()));
-//                if (target == null || shuttleProtocol.getCurrentLocNo().equals(locNo)) {//搴撲綅涓嶅瓨鍦ㄦ垨灏忚溅宸插湪褰撳墠浣嶇疆
-//                    shuttleProtocol.setYCurrent(yCurrent + 1);
-//                    if (shuttleProtocol.getYCurrent() > shuttleProtocol.getYTarget()) {
-//                        //y杞磋窇瀹岋紝鍒囨崲x杞�
-//                        shuttleProtocol.setYCurrent(shuttleProtocol.getYStart());
-//                        shuttleProtocol.setXCurrent(shuttleProtocol.getXCurrent() + 1);
-//
-//                        if(shuttleProtocol.getXCurrent() > shuttleProtocol.getXTarget()) {
-//                            //x杞翠篃璺戝畬浜嗭紝缁撴潫璺戝簱
-//                            shuttleProtocol.setMoveLoc(false);
-//                            shuttleProtocol.setMoveType(0);
-//                            shuttleProtocol.setXStart(0);
-//                            shuttleProtocol.setXTarget(0);
-//                            shuttleProtocol.setXCurrent(0);
-//                            shuttleProtocol.setYStart(0);
-//                            shuttleProtocol.setYTarget(0);
-//                            shuttleProtocol.setYCurrent(0);
-//                            return;
-//                        }
-//                    }
-//                    return;
-//                }
-//
-//                //璋冨害鍘诲簱浣�
-//                Task task = shuttleDispatcher.generateMoveTask(device, locNo);
-//                if (task == null) {
-//                    return;//璋冨害澶辫触
-//                }
-//
-//                shuttleProtocol.setYCurrent(yCurrent + 1);
-//                if (shuttleProtocol.getYCurrent() > shuttleProtocol.getYTarget()) {
-//                    //y杞磋窇瀹岋紝鍒囨崲x杞�
-//                    shuttleProtocol.setYCurrent(shuttleProtocol.getYStart());
-//                    shuttleProtocol.setXCurrent(shuttleProtocol.getXCurrent() + 1);
-//
-//                    if(shuttleProtocol.getXCurrent() > shuttleProtocol.getXTarget()) {
-//                        //x杞翠篃璺戝畬浜嗭紝缁撴潫璺戝簱
-//                        shuttleProtocol.setMoveLoc(false);
-//                        shuttleProtocol.setMoveType(0);
-//                        shuttleProtocol.setXStart(0);
-//                        shuttleProtocol.setXTarget(0);
-//                        shuttleProtocol.setXCurrent(0);
-//                        shuttleProtocol.setYStart(0);
-//                        shuttleProtocol.setYTarget(0);
-//                        shuttleProtocol.setYCurrent(0);
-//                        return;
-//                    }
-//                }
-//
-//            }
-//        } else if (shuttleProtocol.getMoveType() == 2) {//姣嶈建閬撳惊鐜窇
-//            Integer xCurrent = shuttleProtocol.getXCurrent();
-//            Integer yCurrent = shuttleProtocol.getYCurrent();
-//
-//            String locNo = Utils.getLocNo(xCurrent, yCurrent, lev);
-//            //璋冨害鍘荤洰鏍囦綅缃�
-//            if (shuttleProtocol.getCurrentLocNo().equals(locNo)) {
-//                if (yCurrent.equals(shuttleProtocol.getYStart())) {
-//                    shuttleProtocol.setYCurrent(shuttleProtocol.getYTarget());//灏忚溅鍜岀洰鏍囦綅缃竴鑷达紝鍒囨崲搴撲綅
-//                } else {
-//                    shuttleProtocol.setYCurrent(shuttleProtocol.getYStart());//灏忚溅鍜岀洰鏍囦綅缃竴鑷达紝鍒囨崲搴撲綅
-//                }
-//            } else {
-//                Task result = shuttleDispatcher.generateMoveTask(device, locNo);
-//                if (result != null) {//璋冨害鎴愬姛
-//                    if (yCurrent.equals(shuttleProtocol.getYStart())) {
-//                        shuttleProtocol.setYCurrent(shuttleProtocol.getYTarget());//鍒囨崲搴撲綅
-//                    } else {
-//                        shuttleProtocol.setYCurrent(shuttleProtocol.getYStart());//鍒囨崲搴撲綅
-//                    }
-//                }
-//            }
-//        } else if (shuttleProtocol.getMoveType() == 3) {//瀛愯建閬撳惊鐜窇
-//            Integer xCurrent = shuttleProtocol.getXCurrent();
-//            Integer yCurrent = shuttleProtocol.getYCurrent();
-//
-//            String locNo = Utils.getLocNo(xCurrent, yCurrent, lev);
-//            //璋冨害鍘荤洰鏍囦綅缃�
-//            if (shuttleProtocol.getCurrentLocNo().equals(locNo)) {
-//                if (xCurrent.equals(shuttleProtocol.getXStart())) {
-//                    shuttleProtocol.setXCurrent(shuttleProtocol.getXTarget());//灏忚溅鍜岀洰鏍囦綅缃竴鑷达紝鍒囨崲搴撲綅
-//                } else {
-//                    shuttleProtocol.setXCurrent(shuttleProtocol.getXStart());//灏忚溅鍜岀洰鏍囦綅缃竴鑷达紝鍒囨崲搴撲綅
-//                }
-//            } else {
-//                Task result = shuttleDispatcher.generateMoveTask(device, locNo);
-//                if (result != null) {//璋冨害鎴愬姛
-//                    if (xCurrent.equals(shuttleProtocol.getXStart())) {
-//                        shuttleProtocol.setXCurrent(shuttleProtocol.getXTarget());//鍒囨崲搴撲綅
-//                    } else {
-//                        shuttleProtocol.setXCurrent(shuttleProtocol.getXStart());//鍒囨崲搴撲綅
-//                    }
-//                }
-//            }
-//        } else if (shuttleProtocol.getMoveType() == 4) {//鍙栨斁璐�
-//            Integer xCurrent = shuttleProtocol.getXCurrent();
-//            if (xCurrent > shuttleProtocol.getXTarget()) {//褰揦鍊煎ぇ浜嶺鐩爣鍊�
-//                shuttleProtocol.setXCurrent(shuttleProtocol.getXStart());
-//                shuttleProtocol.setYCurrent(shuttleProtocol.getYStart());
-//                return;
-//            }
-//
-//            //鍒ゆ柇x杞磋揣浣嶆槸鍚︽斁婊�
-//            boolean flag = true;
-//            for (Loc loc : locService.list(new LambdaQueryWrapper<Loc>()
-//                    .eq(Loc::getHostId, device.getHostId())
-//                    .eq(Loc::getRow, xCurrent)
-//                    .ge(Loc::getBay, shuttleProtocol.getYStart())
-//                    .le(Loc::getBay, shuttleProtocol.getYTarget()))) {
-//                if (loc.getLocSts() != LocStsType.F.val()) {
-//                    flag = false;//鏈弧
-//                    break;
-//                }
-//            }
-//            if (flag) {
-//                shuttleProtocol.setXCurrent(shuttleProtocol.getXCurrent() + 1);
-//                return;
-//            }
-//
-//            //鎼滅储鏈夎揣搴撲綅
-//            List<Loc> list = locService.list(new LambdaQueryWrapper<Loc>()
-//                    .eq(Loc::getLocSts, LocStsType.F.val())
-//                    .eq(Loc::getHostId, device.getHostId())
-//                    .notIn(Loc::getRow, xCurrent)
-//                    .eq(Loc::getStatus, 1));
-//            if (list.isEmpty()) {
-//                return;
-//            }
-//
-//            Loc start = list.get(0);
-//
-//            List<Loc> locList = locService.list(new LambdaQueryWrapper<Loc>()
-//                    .eq(Loc::getHostId, device.getHostId())
-//                    .eq(Loc::getStatus, 1)
-//                    .eq(Loc::getLocSts, LocStsType.O.val())
-//                    .eq(Loc::getRow, xCurrent)
-//                    .orderByDesc(Loc::getBay)
-//                    .orderByAsc(Loc::getRow));
-//            if (locList.isEmpty()) {
-//                return;
-//            }
-//
-//            Loc target = locList.get(0);
-//            if (target == null) {
-//                return;
-//            }
-//
-//            //璋冨害鍘荤洰鏍囦綅缃�
-//            if (!shuttleProtocol.getCurrentLocNo().equals(target.getLocNo())) {
-//                Task task = shuttleDispatcher.generateManuaTakeMoveTask(device, start.getLocNo(), target.getLocNo());
-////                if(task != null) {//璋冨害鎴愬姛
-////                    shuttleProtocol.setXCurrent(shuttleProtocol.getXCurrent() + 1);
-////                }
-//            }
-//        }
-//    }
+    public synchronized void demoModeRunLoc(Integer shuttleNo) {
+        Config demoModeRunLocConfig = configService.selectOne(new EntityWrapper<Config>().eq("code", "demoModeRunLoc"));
+        if (demoModeRunLocConfig == null) {
+            return;
+        }
 
-    private synchronized CommandResponse write(ShuttleCommand command, Integer shuttleNo) {
+        if (!demoModeRunLocConfig.getValue().equals("Y")) {
+            return;
+        }
+
+        ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, shuttleNo);
+        if (shuttleThread == null) {
+            return;
+        }
+
+        ShuttleProtocol shuttleProtocol = shuttleThread.getStatus();
+        if (shuttleProtocol == null) {
+            return;
+        }
+
+        if (!shuttleThread.isIdle()) {
+            return;
+        }
+
+        LocMast targetLoc = null;
+        EntityWrapper<LocMast> wrapper = new EntityWrapper<>();
+        wrapper.eq("lev1", Utils.getLev(shuttleProtocol.getCurrentLocNo()));
+        wrapper.notIn("loc_sts", "X");
+        wrapper.isNull("loc_type");
+        wrapper.last("ORDER BY RAND() LIMIT 1");
+        for (int i = 0; i < 3; i++) {
+            LocMast locMast = locMastService.selectOne(wrapper);
+            if(locMast == null) {
+                continue;
+            }
+
+            targetLoc = locMast;
+            break;
+        }
+
+        if(targetLoc == null) {
+            return;
+        }
+
+        boolean result = shuttleDispatchUtils.dispatchShuttle(null, targetLoc.getLocNo(), shuttleProtocol.getShuttleNo());
+        if (result) {
+            targetLoc.setLocType("Y");
+            locMastService.updateById(targetLoc);
+        }
+    }
+
+    public synchronized boolean clearPath(Integer shuttleNo) {
+        return navigateMapUtils.clearPath(shuttleNo);
+    }
+
+    private CommandResponse write(ShuttleCommand command, Integer shuttleNo) {
         CommandResponse response = new CommandResponse(false);
         if (null == command) {
             News.error("鍥涘悜绌挎杞﹀啓鍏ュ懡浠や负绌�");

--
Gitblit v1.9.1