From 7635dc25bd2a4d565df496b2d96354639966768d Mon Sep 17 00:00:00 2001
From: Junjie <xjj@123>
Date: 星期四, 25 九月 2025 11:09:44 +0800
Subject: [PATCH] #

---
 src/main/java/com/zy/asrs/service/impl/MainServiceImpl.java | 1141 ++++++++++++++++++++++++++++++++------------------------
 1 files changed, 655 insertions(+), 486 deletions(-)

diff --git a/src/main/java/com/zy/asrs/service/impl/MainServiceImpl.java b/src/main/java/com/zy/asrs/service/impl/MainServiceImpl.java
index 2db8c2b..94dfa94 100644
--- a/src/main/java/com/zy/asrs/service/impl/MainServiceImpl.java
+++ b/src/main/java/com/zy/asrs/service/impl/MainServiceImpl.java
@@ -2,6 +2,7 @@
 
 import com.alibaba.fastjson.JSON;
 import com.baomidou.mybatisplus.mapper.EntityWrapper;
+import com.core.common.SpringUtils;
 import com.zy.asrs.domain.enums.NotifyMsgType;
 import com.zy.asrs.entity.*;
 import com.zy.asrs.service.*;
@@ -12,15 +13,14 @@
 import com.zy.common.service.CommonService;
 import com.zy.common.utils.*;
 import com.zy.core.News;
-import com.zy.core.action.ForkLiftAction;
+import com.zy.core.action.LiftAction;
 import com.zy.core.action.ShuttleAction;
 import com.zy.core.cache.SlaveConnection;
+import com.zy.core.dispatcher.LiftDispatchUtils;
 import com.zy.core.dispatcher.ShuttleDispatchUtils;
 import com.zy.core.enums.*;
-import com.zy.core.model.*;
 import com.zy.core.model.command.*;
 import com.zy.core.model.protocol.*;
-import com.zy.core.properties.SlaveProperties;
 import com.zy.core.thread.*;
 import com.zy.system.entity.Config;
 import com.zy.system.service.ConfigService;
@@ -38,8 +38,6 @@
 @Service("mainService")
 public class MainServiceImpl {
 
-    @Autowired
-    private SlaveProperties slaveProperties;
     @Autowired
     private WrkMastService wrkMastService;
     @Autowired
@@ -61,8 +59,6 @@
     @Autowired
     private ConfigService configService;
     @Autowired
-    private NavigateMapUtils navigateMapUtils;
-    @Autowired
     private NavigateMapData navigateMapData;
     @Autowired
     private NavigateUtils navigateUtils;
@@ -71,39 +67,44 @@
     @Autowired
     private ShuttleAction shuttleAction;
     @Autowired
-    private ForkLiftAction forkLiftAction;
+    private LiftAction liftAction;
     @Autowired
     private NotifyUtils notifyUtils;
+    @Autowired
+    private BasShuttleChargeService basShuttleChargeService;
+    @Autowired
+    private DeviceConfigService deviceConfigService;
+    @Autowired
+    private LiftDispatchUtils liftDispatchUtils;
+    @Autowired
+    private BasShuttleService basShuttleService;
 
     /**
      * 鍒濆鍖栧疄鏃跺湴鍥�
      */
     public synchronized void initRealtimeBasMap() {
         try {
-            for (int i = 1; i <= 4; i++) {//鎬诲叡鍥涘眰妤�
-                Object data = redisUtil.get(RedisKeyType.MAP.key + i);
-                if (data == null) {//redis鍦板浘鏁版嵁涓虹┖锛屼粠鏁版嵁搴撲腑鑾峰彇
-                    BasMap basMap = basMapService.selectLatestMap(i);
-                    if (basMap == null) {
-                        //鏁版嵁搴撲腑涔熶笉瀛樺湪鍦板浘鏁版嵁锛屼粠鍦板浘鏂囦欢涓幏鍙�
-                        //杞藉叆鍦板浘
-                        List<List<MapNode>> lists = navigateMapData.getJsonData(i, -1, null, null);//鑾峰彇瀹屾暣鍦板浘(鍖呮嫭鍏ュ簱鍑哄簱)
 
-                        //瀛樺叆鏁版嵁搴�
-                        basMap = new BasMap();
-                        basMap.setData(JSON.toJSONString(lists));
-                        basMap.setCreateTime(new Date());
-                        basMap.setUpdateTime(new Date());
-                        basMap.setLev(i);
+            List<BasMap> basMaps = basMapService.selectList(new EntityWrapper<BasMap>().orderBy("lev", true));
+            for (BasMap basMap : basMaps) {
+                Integer lev = basMap.getLev();
+                Object data = redisUtil.get(RedisKeyType.MAP.key + lev);
+                if (data == null) {//redis鍦板浘鏁版嵁涓虹┖
+                    //杞藉叆鍦板浘
+                    List<List<MapNode>> lists = navigateMapData.getJsonOriginData(lev, NavigationMapType.getMapTypes(NavigationMapType.NONE), null, null);//鑾峰彇瀹屾暣鍦板浘(鍖呮嫭鍏ュ簱鍑哄簱)
 
-                        if (!basMapService.insert(basMap)) {
-                            log.info("鍦板浘鏁版嵁瀛樺偍澶辫触");
-                        }
+                    //瀛樺叆鏁版嵁搴�
+                    basMap.setData(JSON.toJSONString(lists));
+                    basMap.setCreateTime(new Date());
+                    basMap.setUpdateTime(new Date());
+                    if (!basMapService.updateById(basMap)) {
+                        log.info("鍦板浘鏁版嵁瀛樺偍澶辫触");
                     }
 
                     //灏嗘暟鎹簱鍦板浘鏁版嵁瀛樺叆redis
-                    redisUtil.set(RedisKeyType.MAP.key + i, JSON.toJSONString(basMap));
+                    redisUtil.set(RedisKeyType.MAP.key + lev, lists);
                 }
+
             }
         } catch (Exception e) {
             e.printStackTrace();
@@ -118,9 +119,13 @@
             List<WrkMast> wrkMasts = wrkMastService.selectList(new EntityWrapper<WrkMast>()
                     .in("wrk_sts"
                             , WrkStsType.INBOUND_LIFT_RUN_COMPLETE.sts
-                    ));
+                    )
+                    .orderBy("io_pri", false)
+                    .orderBy("appe_time", true)
+            );
             for (WrkMast wrkMast : wrkMasts) {
                 boolean step1 = this.shuttleInExecuteStep1(wrkMast);//灏忚溅鎼叆搴撲腑
+                Thread.sleep(100);
                 if (!step1) {
                     continue;
                 }
@@ -135,7 +140,7 @@
      * 濡傞渶涓绘柟娉曟墽琛宑ontinue锛岃杩斿洖false
      * ps:杩斿洖鍊紅rue骞朵笉浠ｈ〃璇ユ柟娉曟墽琛屾垚鍔燂紝杩斿洖鍊间粎鍋氭爣璁扮敤浜庝富鏂规硶鏄惁鎵цcontinue
      */
-    public boolean shuttleInExecuteStep1(WrkMast wrkMast) {
+    public synchronized boolean shuttleInExecuteStep1(WrkMast wrkMast) {
         if (wrkMast.getWrkSts() == WrkStsType.INBOUND_LIFT_RUN_COMPLETE.sts) {
             //鑾峰彇鐩爣绔�
             ForkLiftStaProtocol liftSta = ForkLiftUtils.getLiftStaByStaNo(wrkMast.getStaNo());
@@ -179,6 +184,15 @@
                 return false;
             }
 
+            //妫�娴嬮殰纰嶇墿杞�
+            int checkObstacle = shuttleOperaUtils.checkObstacle(wrkMast.getLocNo(), new ArrayList<Integer>() {{
+                add(shuttleProtocol.getShuttleNo());
+            }}, new ArrayList<>());
+            if (checkObstacle > 0) {
+                News.info("{}浠诲姟锛岄伩闅滆寖鍥存湁灏忚溅锛岀瓑寰呴殰纰嶅皬杞﹁皟绂讳腑", wrkMast.getWrkNo());
+                return false;
+            }
+
             ShuttleAssignCommand assignCommand = new ShuttleAssignCommand();
             assignCommand.setShuttleNo(shuttleProtocol.getShuttleNo()); // 鍥涘悜绌挎杞︾紪鍙�
             assignCommand.setTaskMode(ShuttleTaskModeType.TRANSPORT.id);//灏忚溅绉诲簱浠诲姟
@@ -186,7 +200,7 @@
             assignCommand.setAuto(true);//鑷姩妯″紡
 
             //鑾峰彇灏忚溅鍒拌緭閫佺珯鐐硅璧板懡浠�
-            List<ShuttleCommand> commands = shuttleOperaUtils.getStartToTargetCommands(liftSta.getLocNo(), wrkMast.getLocNo(), NavigationMapType.DFX.id, assignCommand, shuttleThread);
+            List<ShuttleCommand> commands = shuttleOperaUtils.getStartToTargetCommands(liftSta.getLocNo(), wrkMast.getLocNo(), NavigationMapType.getDfxWithDevice(), assignCommand, shuttleThread);
             if (commands == null) {
                 News.taskInfo(wrkMast.getWrkNo(), "{}浠诲姟锛寋}灏忚溅锛岃矾寰勮绠楀け璐�", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                 return false;
@@ -231,9 +245,13 @@
             List<WrkMast> wrkMasts = wrkMastService.selectList(new EntityWrapper<WrkMast>()
                     .in("wrk_sts"
                             , WrkStsType.NEW_OUTBOUND.sts
-                    ));
+                    )
+                    .orderBy("io_pri", false)
+                    .orderBy("appe_time", true)
+            );
             for (WrkMast wrkMast : wrkMasts) {
                 boolean step1 = this.shuttleOutExecuteStep1(wrkMast);//灏忚溅鎼嚭搴撲腑
+                Thread.sleep(100);
                 if (!step1) {
                     continue;
                 }
@@ -248,7 +266,7 @@
      * 濡傞渶涓绘柟娉曟墽琛宑ontinue锛岃杩斿洖false
      * ps:杩斿洖鍊紅rue骞朵笉浠ｈ〃璇ユ柟娉曟墽琛屾垚鍔燂紝杩斿洖鍊间粎鍋氭爣璁扮敤浜庝富鏂规硶鏄惁鎵цcontinue
      */
-    public boolean shuttleOutExecuteStep1(WrkMast wrkMast) {
+    public synchronized boolean shuttleOutExecuteStep1(WrkMast wrkMast) {
         //101.鐢熸垚鍑哄簱浠诲姟 => 102.灏忚溅鎼繍涓�
         if (wrkMast.getWrkSts() == WrkStsType.NEW_OUTBOUND.sts) {
             Integer liftNo = wrkMast.getLiftNo();
@@ -259,20 +277,6 @@
                     News.taskInfo(wrkMast.getWrkNo(), "{}浠诲姟锛屾湭鎵惧埌鍖归厤鐨勬彁鍗囨満", wrkMast.getWrkNo());
                     return false;
                 }
-
-                //鍒ゆ柇鎻愬崌鏈烘槸鍚︽湁鍏朵粬浠诲姟
-                WrkMast liftWrkMast = wrkMastService.selectLiftWrkMast(liftNo);
-                if (liftWrkMast != null) {
-                    if (!liftWrkMast.getWrkNo().equals(wrkMast.getWrkNo())) {//鎻愬崌鏈轰换鍔″拰褰撳墠浠诲姟涓嶇浉鍚�
-                        News.taskInfo(wrkMast.getWrkNo(), "{}浠诲姟锛寋}鍙锋彁鍗囨満锛屾彁鍗囨満瀛樺湪鏈畬鎴愪换鍔★紝绂佹娲惧彂", wrkMast.getWrkNo(), wrkMast.getLiftNo());
-                        return false;
-                    }
-                }
-
-                wrkMast.setLiftNo(liftNo);
-                wrkMast.setModiTime(new Date());
-                wrkMastService.updateById(wrkMast);
-                return false;
             }
 
             ForkLiftThread forkLiftThread = (ForkLiftThread) SlaveConnection.get(SlaveType.ForkLift, liftNo);
@@ -298,12 +302,35 @@
             }
 
             if (liftSta.getHasCar()) {
-                News.taskInfo(wrkMast.getWrkNo(), "{}浠诲姟锛寋}绔欑偣瀛樺湪灏忚溅锛岀姝㈡淳鍙�", wrkMast.getWrkNo(), liftSta.getStaNo());
+                News.taskInfo(wrkMast.getWrkNo(), "{}浠诲姟锛寋}绔欑偣瀛樺湪灏忚溅锛岀姝㈡淳鍙�", wrkMast.getWrkNo(), liftSta.getSiteId());
                 return false;
             }
 
             if (liftSta.getHasTray()) {
-                News.taskInfo(wrkMast.getWrkNo(), "{}浠诲姟锛寋}绔欑偣鏈夋墭鐩橈紝绂佹娲惧彂", wrkMast.getWrkNo(), liftSta.getStaNo());
+                News.taskInfo(wrkMast.getWrkNo(), "{}浠诲姟锛寋}绔欑偣鏈夋墭鐩橈紝绂佹娲惧彂", wrkMast.getWrkNo(), liftSta.getSiteId());
+                return false;
+            }
+
+            List<WrkMast> shuttleMoveList = wrkMastService.selectList(new EntityWrapper<WrkMast>()
+                    .eq("io_type", 200)
+            );
+            for (WrkMast moveWrkMast : shuttleMoveList) {
+                if(Utils.getLev(moveWrkMast.getLocNo()) != Utils.getLev(wrkMast.getSourceLocNo())) {
+                    continue;
+                }
+
+                if(Utils.getLev(moveWrkMast.getLocNo()) == Utils.getLev(moveWrkMast.getSourceLocNo())) {
+                    continue;
+                }
+
+                //瀛樺湪鎹㈠眰浠诲姟锛屽嚭搴撲换鍔℃殏鏃朵笉鎵ц
+                News.taskInfo(wrkMast.getWrkNo(), "{}浠诲姟锛屽瓨鍦ㄦ崲灞備换鍔★紝鍑哄簱浠诲姟绛夊緟涓�", wrkMast.getWrkNo());
+                return false;
+            }
+
+            boolean checkLocPathIsAvailable = navigateUtils.checkLocPathIsAvailable(wrkMast.getSourceLocNo(), liftSta.getLocNo());
+            if(!checkLocPathIsAvailable) {
+                News.taskInfo(wrkMast.getWrkNo(), "{}浠诲姟锛屾湭璁＄畻鍒板彲鎵ц璺緞锛岀瓑寰呬腑", wrkMast.getWrkNo());
                 return false;
             }
 
@@ -311,7 +338,7 @@
                 //寮哄埗棰勭暀涓�鍙板皬杞︾粰鍏ュ簱浠诲姟
                 int lev = Utils.getLev(wrkMast.getSourceLocNo());
                 //鑾峰彇褰撳墠妤煎眰鏈夊嚑鍙板彲鐢ㄥ皬杞�
-                int shuttleCount = shuttleDispatchUtils.getShuttleCountByLev(lev);
+                int shuttleCount = shuttleDispatchUtils.getShuttleEnableUseCountByLev(lev);
                 if (shuttleCount >= 2) {//鍙湁鍙敤灏忚溅鏁伴噺澶т簬2锛屾墠杩涜鍏ュ簱浠诲姟棰勭暀灏忚溅
                     int shuttleWrkInObligateCount = 1;//棰勭暀灏忚溅鏁伴噺
                     Config config = configService.selectOne(new EntityWrapper<Config>().eq("code", "shuttleWrkInObligateCount").eq("status", 1));
@@ -348,9 +375,25 @@
 
             //鍒ゆ柇灏忚溅鏄惁鍒拌揪璐х墿搴撲綅
             if (!shuttleProtocol.getCurrentLocNo().equals(wrkMast.getSourceLocNo())) {
+                //妫�娴嬮殰纰嶇墿杞�
+                int checkObstacle = shuttleOperaUtils.checkObstacle(wrkMast.getSourceLocNo(), new ArrayList<Integer>() {{
+                    add(shuttleProtocol.getShuttleNo());
+                }}, new ArrayList<>());
+                if (checkObstacle > 0) {
+                    News.info("{}浠诲姟锛岄伩闅滆寖鍥存湁灏忚溅锛岀瓑寰呴殰纰嶅皬杞﹁皟绂讳腑", wrkMast.getWrkNo());
+                    return false;
+                }
+
                 //灏忚溅涓嶅湪杈撻�佺珯鐐逛綅缃�
                 shuttleDispatchUtils.dispatchShuttle(wrkMast.getWrkNo(), wrkMast.getSourceLocNo(), wrkMast.getShuttleNo());//璋冨害灏忚溅鍒拌揣鐗╂墍鍦ㄥ簱浣嶈繘琛屽彇璐�
                 News.taskInfo(wrkMast.getWrkNo(), "{}浠诲姟锛寋}灏忚溅锛屾湭鍒拌揪杈撻�佺珯鐐癸紝绯荤粺绛夊緟涓�", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
+                return false;
+            }
+
+            //妫�娴嬫槸鍚﹀瓨鍦ㄧЩ鍔ㄤ换鍔�
+            WrkMast moveWorking = wrkMastService.selectShuttleHasMoveWorking(wrkMast.getShuttleNo());
+            if (moveWorking != null) {
+                News.taskInfo(wrkMast.getWrkNo(), "{}浠诲姟锛屽皬杞﹀瓨鍦ㄧЩ鍔ㄤ换鍔�", wrkMast.getWrkNo());
                 return false;
             }
 
@@ -361,7 +404,7 @@
             assignCommand.setAuto(true);//鑷姩妯″紡
 
             //鑾峰彇灏忚溅鍒拌緭閫佺珯鐐硅璧板懡浠�
-            List<ShuttleCommand> commands = shuttleOperaUtils.getStartToTargetCommands(wrkMast.getSourceLocNo(), liftSta.getLocNo(), NavigationMapType.DFX.id, assignCommand, shuttleThread);
+            List<ShuttleCommand> commands = shuttleOperaUtils.getStartToTargetCommands(wrkMast.getSourceLocNo(), liftSta.getLocNo(), NavigationMapType.getDfxWithDevice(), assignCommand, shuttleThread);
             if (commands == null) {
                 News.taskInfo(wrkMast.getWrkNo(), "{}浠诲姟锛寋}灏忚溅锛岃矾寰勮绠楀け璐�", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                 return false;
@@ -384,7 +427,7 @@
             assignCommand.setCommands(commands);
 
             wrkMast.setWrkSts(WrkStsType.OUTBOUND_SHUTTLE_RUN.sts);//灏忚溅鎼繍涓�  101.鐢熸垚鍑哄簱浠诲姟 ==> 102.灏忚溅鎼繍涓�
-            wrkMast.setSourceStaNo(liftSta.getStaNo());
+            wrkMast.setSourceStaNo(liftSta.getSiteId());
             wrkMast.setModiTime(new Date());
             wrkMast.setSystemMsg("");//娓呯┖娑堟伅
             if (wrkMastService.updateById(wrkMast)) {
@@ -400,96 +443,16 @@
     }
 
     /**
-     * 鍥涘悜绌挎杞︿换鍔″畬鎴�
-     */
-    public synchronized void shuttleFinished() {
-        try {
-            for (ShuttleSlave shuttle : slaveProperties.getShuttle()) {
-                //鑾峰彇鍥涘悜绌挎杞︿俊鎭�
-                ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, shuttle.getId());
-                ShuttleProtocol shuttleProtocol = shuttleThread.getStatus();
-                if (shuttleProtocol == null) {
-                    continue;
-                }
-
-                //鍥涘悜绌挎杞︾姸鎬佷负绛夊緟纭銆佸皬杞﹀浜庣┖闂茬姸鎬�
-                if (shuttleProtocol.getProtocolStatus() == ShuttleProtocolStatusType.WAITING.id  //浠诲姟瀹屾垚绛夊緟纭
-                        && shuttleProtocol.getTaskNo() != 0
-                ) {
-                    //灏嗕换鍔℃。鏍囪涓哄畬鎴�
-                    WrkMast wrkMast = wrkMastService.selectByWorkNo(shuttleProtocol.getTaskNo());
-                    if (wrkMast != null) {
-                        if (wrkMast.getWrkSts() == WrkStsType.INBOUND_SHUTTLE_RUN.sts) {
-                            //5.灏忚溅鎼繍涓� ==> 9.鍏ュ簱瀹屾垚
-                            wrkMast.setWrkSts(WrkStsType.COMPLETE_INBOUND.sts);
-                            shuttleThread.setSyncTaskNo(0);
-                        } else if (wrkMast.getWrkSts() == WrkStsType.OUTBOUND_SHUTTLE_RUN.sts) {
-                            //102.灏忚溅鎼繍涓� ==> 103.灏忚溅鎼繍瀹屾垚
-                            wrkMast.setWrkSts(WrkStsType.OUTBOUND_SHUTTLE_RUN_COMPLETE.sts);
-                            shuttleThread.setSyncTaskNo(0);
-                        } else if (wrkMast.getWrkSts() == WrkStsType.MOVE_SITE.sts) {
-                            //302.灏忚溅绉诲姩鑷崇珯鐐� ==> 303.灏忚溅绉诲姩鑷崇珯鐐瑰畬鎴�
-                            wrkMast.setWrkSts(WrkStsType.MOVE_SITE_COMPLETE.sts);
-                            shuttleThread.setSyncTaskNo(0);
-                        } else if (wrkMast.getWrkSts() == WrkStsType.MOVE_OUT_LIFT.sts) {
-                            //308.灏忚溅杩佸嚭鎻愬崌鏈轰腑 ==> 309.灏忚溅杩佸嚭鎻愬崌鏈哄畬鎴�
-                            wrkMast.setWrkSts(WrkStsType.MOVE_OUT_LIFT_COMPLETE.sts);
-                            shuttleThread.setSyncTaskNo(0);
-                        } else if (wrkMast.getWrkSts() == WrkStsType.MOVE_SHUTTLE.sts) {
-                            //310.灏忚溅绉诲姩涓� ==> 311.灏忚溅绉诲姩瀹屾垚
-                            wrkMast.setWrkSts(WrkStsType.COMPLETE_MOVE.sts);
-                            shuttleThread.setSyncTaskNo(0);
-                            notifyUtils.notify(String.valueOf(SlaveType.Shuttle), shuttleProtocol.getShuttleNo(), String.valueOf(wrkMast.getWrkNo()), wrkMast.getWmsWrkNo(), NotifyMsgType.SHUTTLE_MOVE_COMPLETE);//瑙﹀彂閫氱煡
-                        } else if (wrkMast.getWrkSts() == WrkStsType.CHARGE_SHUTTLE_WORKING.sts) {
-                            //204.灏忚溅鍏呯數涓� ==> 205.灏忚溅鍏呯數瀹屾垚
-                            wrkMast.setWrkSts(WrkStsType.CHARGE_SHUTTLE_COMPLETE.sts);
-                            shuttleThread.setSyncTaskNo(0);
-                            notifyUtils.notify(String.valueOf(SlaveType.Shuttle), shuttleProtocol.getShuttleNo(), String.valueOf(wrkMast.getWrkNo()), wrkMast.getWmsWrkNo(), NotifyMsgType.SHUTTLE_POWER_COMPLETE);//瑙﹀彂閫氱煡
-                        } else if (wrkMast.getWrkSts() == WrkStsType.LOC_MOVE_SHUTTLE_RUN.sts) {
-                            //502.灏忚溅鎼繍涓� ==> 509.绉诲簱瀹屾垚
-                            wrkMast.setWrkSts(WrkStsType.COMPLETE_LOC_MOVE.sts);
-                            shuttleThread.setSyncTaskNo(0);
-                            notifyUtils.notify(String.valueOf(SlaveType.Shuttle), shuttleProtocol.getShuttleNo(), String.valueOf(wrkMast.getWrkNo()), wrkMast.getWmsWrkNo(), NotifyMsgType.SHUTTLE_DELIVERY);//瑙﹀彂閫氱煡
-                        } else {
-                            continue;
-                        }
-
-                        if (wrkMastService.updateById(wrkMast)) {
-                            //璁剧疆鍥涘悜绌挎杞︿负绌洪棽鐘舵��
-                            shuttleThread.setProtocolStatus(ShuttleProtocolStatusType.IDLE);
-                            News.info("鍥涘悜绌挎杞﹀凡纭涓斾换鍔″畬鎴愮姸鎬�,澶嶄綅銆傚洓鍚戠┛姊溅鍙�={}", shuttleProtocol.getShuttleNo());
-                        } else {
-                            News.error("鍥涘悜绌挎杞﹀凡纭涓斾换鍔″畬鎴愮姸鎬�,澶嶄綅澶辫触锛屼絾鏈壘鍒板伐浣滄。銆傚洓鍚戠┛姊溅鍙�={}锛屽伐浣滃彿={}", shuttleProtocol.getShuttleNo(), shuttleProtocol.getTaskNo());
-                        }
-                    } else {
-                        Object object = redisUtil.get(RedisKeyType.SHUTTLE_WORK_FLAG.key + shuttleProtocol.getTaskNo());
-                        if(object != null){
-                            ShuttleAssignCommand assignCommand = JSON.parseObject(object.toString(), ShuttleAssignCommand.class);
-                            if (!assignCommand.getAuto()) {
-                                //鎵嬪姩妯″紡
-                                //宸ヤ綔鍙锋竻闆�
-                                shuttleThread.setTaskNo(0);
-                                //璁剧疆鍥涘悜绌挎杞︿负绌洪棽鐘舵��
-                                shuttleThread.setProtocolStatus(ShuttleProtocolStatusType.IDLE);
-                                News.info("鍥涘悜绌挎杞﹀凡纭涓斾换鍔″畬鎴愮姸鎬�,澶嶄綅銆傚洓鍚戠┛姊溅鍙�={}", shuttleProtocol.getShuttleNo());
-                            }
-                        }
-                    }
-                }
-
-            }
-        } catch (Exception e) {
-            e.printStackTrace();
-        }
-    }
-
-    /**
      * 鎵ц绉诲簱浠诲姟
      */
     public synchronized void shuttleLocMoveExecute() {
         try {
             //鏌ヨ绉诲簱浠诲姟
-            List<WrkMast> wrkMasts = wrkMastService.selectList(new EntityWrapper<WrkMast>().in("wrk_sts", WrkStsType.NEW_LOC_MOVE.sts));
+            List<WrkMast> wrkMasts = wrkMastService.selectList(new EntityWrapper<WrkMast>()
+                    .in("wrk_sts", WrkStsType.NEW_LOC_MOVE.sts)
+                    .orderBy("io_pri", false)
+                    .orderBy("appe_time", true)
+            );
             for (WrkMast wrkMast : wrkMasts) {
                 boolean stepToTarget = this.shuttleLocMoveExecuteToTarget(wrkMast);//绉诲簱浠诲姟-灏忚溅鍘荤洰鏍囩偣
                 if (!stepToTarget) {
@@ -513,6 +476,12 @@
 
         //灏忚溅绉诲姩鑷崇珯鐐�  501.鐢熸垚绉诲簱浠诲姟 ==> 502.灏忚溅鎼繍涓�
         if (wrkMast.getWrkSts() == WrkStsType.NEW_LOC_MOVE.sts) {
+            boolean checkLocPathIsAvailable = navigateUtils.checkLocPathIsAvailable(wrkMast.getSourceLocNo(), wrkMast.getLocNo());
+            if(!checkLocPathIsAvailable) {
+                News.taskInfo(wrkMast.getWrkNo(), "{}浠诲姟锛屾湭璁＄畻鍒板彲鎵ц璺緞锛岀瓑寰呬腑", wrkMast.getWrkNo());
+                return false;
+            }
+
             if (wrkMast.getShuttleNo() == null) {//娌℃湁缁戝畾灏忚溅锛岃繘琛岃皟搴�
                 boolean result = shuttleDispatchUtils.dispatchShuttle(wrkMast.getWrkNo(), wrkMast.getSourceLocNo());//璋冨害灏忚溅鍒拌揣鐗╃偣杩涜鍙栬揣
                 News.info("{}浠诲姟锛岃皟搴﹀皬杞}绯荤粺绛夊緟涓�", wrkMast.getWrkNo(), result ? "鎴愬姛" : "澶辫触");
@@ -529,8 +498,37 @@
                 return false;
             }
 
+            if (shuttleProtocol.getCurrentLocNo() == null) {
+                return false;
+            }
+
+            //鍒ゆ柇灏忚溅鏄惁鍒拌揪璐х墿搴撲綅
             if (!shuttleProtocol.getCurrentLocNo().equals(wrkMast.getSourceLocNo())) {
+                //浠诲姟琚伩闅滃彇娑�
+                Object cancelLock = redisUtil.get(RedisKeyType.TRAFFIC_CONTROL_SHUTTLE_OBSTACLE_CANCEL_TASK_LOCK.key + wrkMast.getShuttleNo());
+                if(cancelLock != null) {
+                    return false;
+                }
+
+                //灏忚溅鏈埌杈惧彇璐т綅缃�
+                shuttleDispatchUtils.dispatchShuttle(wrkMast.getWrkNo(), wrkMast.getSourceLocNo(), wrkMast.getShuttleNo());//璋冨害灏忚溅鍒拌揣鐗╂墍鍦ㄥ簱浣嶈繘琛屽彇璐�
                 News.taskInfo(wrkMast.getWrkNo(), "{}浠诲姟锛屽皬杞︽湭鍒拌揪鍙栬揣浣嶇疆", wrkMast.getWrkNo(), wrkMast.getSourceLocNo());
+                return false;
+            }
+
+            //妫�娴嬫槸鍚﹀瓨鍦ㄧЩ鍔ㄤ换鍔�
+            WrkMast moveWorking = wrkMastService.selectShuttleHasMoveWorking(wrkMast.getShuttleNo());
+            if (moveWorking != null) {
+                News.taskInfo(wrkMast.getWrkNo(), "{}浠诲姟锛屽皬杞﹀瓨鍦ㄧЩ鍔ㄤ换鍔�", wrkMast.getWrkNo());
+                return false;
+            }
+
+            //妫�娴嬮殰纰嶇墿杞�
+            int checkObstacle = shuttleOperaUtils.checkObstacle(wrkMast.getLocNo(), new ArrayList<Integer>() {{
+                add(shuttleProtocol.getShuttleNo());
+            }}, new ArrayList<>());
+            if (checkObstacle > 0) {
+                News.info("{}浠诲姟锛岄伩闅滆寖鍥存湁灏忚溅锛岀瓑寰呴殰纰嶅皬杞﹁皟绂讳腑", wrkMast.getWrkNo());
                 return false;
             }
 
@@ -539,9 +537,10 @@
             assignCommand.setTaskMode(ShuttleTaskModeType.TRANSPORT.id);//灏忚溅绉诲簱浠诲姟
             assignCommand.setTaskNo(wrkMast.getWrkNo());//浠诲姟鍙�
             assignCommand.setAuto(true);//鑷姩妯″紡
+            assignCommand.setLocNo(wrkMast.getLocNo());
 
             //鑾峰彇灏忚溅鍒拌緭閫佺珯鐐硅璧板懡浠�
-            List<ShuttleCommand> commands = shuttleOperaUtils.getStartToTargetCommands(wrkMast.getSourceLocNo(), wrkMast.getLocNo(), NavigationMapType.DFX.id, assignCommand, shuttleThread);
+            List<ShuttleCommand> commands = shuttleOperaUtils.getStartToTargetCommands(wrkMast.getSourceLocNo(), wrkMast.getLocNo(), NavigationMapType.getMapTypes(NavigationMapType.DFX), assignCommand, shuttleThread);
             if (commands == null) {
                 News.taskInfo(wrkMast.getWrkNo(), "{}浠诲姟锛寋}灏忚溅锛岃矾寰勮绠楀け璐�", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                 return false;
@@ -579,9 +578,9 @@
     }
 
     /**
-     * 璐у弶鎻愬崌鏈轰换鍔�
+     * 鎻愬崌鏈轰换鍔�
      */
-    public synchronized void forkLiftIoExecute() {
+    public synchronized void liftIoExecute() {
         try {
             //鎼滅储鏄惁鏈夊緟澶勭悊鐨勪换鍔�
             List<WrkMast> wrkMasts = wrkMastService.selectList(new EntityWrapper<WrkMast>()
@@ -591,59 +590,6 @@
             }
 
             for (WrkMast wrkMast : wrkMasts) {
-                Integer liftNo = wrkMast.getLiftNo();
-                if (liftNo == null) {
-                    //鏈垎閰嶆彁鍗囨満
-                    Integer staNo = wrkMast.getIoType() == WrkIoType.IN.id ? wrkMast.getSourceStaNo() : wrkMast.getStaNo();
-                    liftNo = ForkLiftUtils.getConveyorBindLiftNo(staNo);
-                    if(liftNo == null) {
-                        News.taskInfo(wrkMast.getWrkNo(), "{}浠诲姟锛屾湭鎵惧埌鍖归厤鐨勬彁鍗囨満", wrkMast.getWrkNo());
-                        continue;
-                    }
-
-                    ForkLiftThread forkLiftThread = (ForkLiftThread) SlaveConnection.get(SlaveType.ForkLift, liftNo);
-                    if (forkLiftThread == null) {
-                        continue;
-                    }
-                    ForkLiftProtocol forkLiftProtocol = forkLiftThread.getStatus();
-                    if (forkLiftProtocol == null) {
-                        continue;
-                    }
-
-                    if (!forkLiftThread.isIdle()) {
-                        News.info("{}鍙锋彁鍗囨満锛屽繖纰屼腑", liftNo);
-                        continue;
-                    }
-
-                    //鍒ゆ柇鎻愬崌鏈烘槸鍚︽湁鍏朵粬浠诲姟
-                    WrkMast liftWrkMast = wrkMastService.selectLiftWrkMast(wrkMast.getLiftNo());
-                    if (liftWrkMast != null) {
-                        if (!liftWrkMast.getWrkNo().equals(wrkMast.getWrkNo())) {//鎻愬崌鏈轰换鍔″拰褰撳墠浠诲姟涓嶇浉鍚�
-                            News.taskInfo(wrkMast.getWrkNo(), "{}浠诲姟锛寋}鍙锋彁鍗囨満锛屾彁鍗囨満瀛樺湪鏈畬鎴愪换鍔★紝绂佹娲惧彂", wrkMast.getWrkNo(), wrkMast.getLiftNo());
-                            continue;//褰撳墠鎻愬崌鏈哄瓨鍦ㄦ湭瀹屾垚浠诲姟锛岀瓑寰呬笅涓�娆¤疆璇�
-                        }
-                    }
-
-                    wrkMast.setLiftNo(liftNo);
-                    wrkMast.setModiTime(new Date());
-                    wrkMastService.updateById(wrkMast);
-                    continue;
-                }
-
-                ForkLiftThread forkLiftThread = (ForkLiftThread) SlaveConnection.get(SlaveType.ForkLift, liftNo);
-                if (forkLiftThread == null) {
-                    continue;
-                }
-                ForkLiftProtocol forkLiftProtocol = forkLiftThread.getStatus();
-                if (forkLiftProtocol == null) {
-                    continue;
-                }
-
-                if (!forkLiftThread.isIdle()) {
-                    News.info("{}鍙锋彁鍗囨満锛屽繖纰屼腑", liftNo);
-                    continue;
-                }
-
                 boolean stepIn = this.liftIoExecuteStepIn(wrkMast);//鎻愬崌鏈哄叆搴�
                 if (!stepIn) {
                     continue;
@@ -686,35 +632,7 @@
                 return false;
             }
 
-            ForkLiftThread forkLiftThread = (ForkLiftThread) SlaveConnection.get(SlaveType.ForkLift, liftSta.getLiftNo());
-            if (forkLiftThread == null) {
-                return false;
-            }
-            ForkLiftProtocol forkLiftProtocol = forkLiftThread.getStatus();
-            if (forkLiftProtocol == null) {
-                return false;
-            }
-            if (!forkLiftThread.isIdle()) {
-                News.taskInfo(wrkMast.getWrkNo(), "{}浠诲姟锛寋}鍙锋彁鍗囨満锛屽繖纰屼腑", wrkMast.getWrkNo(), liftSta.getLiftNo());
-                return false;
-            }
-
-            //鍒ゆ柇鎻愬崌鏈烘槸鍚﹀浜庡叆搴撴ā寮�
-            if (!forkLiftProtocol.getIOModeType().equals(ForkLiftIoModeType.IN)) {
-                News.taskInfo(wrkMast.getWrkNo(), "{}浠诲姟锛屾彁鍗囨満涓嶅浜庡叆搴撴ā寮忥紝绂佹鍏ュ簱", wrkMast.getWrkNo());
-                return false;
-            }
-
-            //鍒ゆ柇鎻愬崌鏈烘槸鍚︽湁鍏朵粬浠诲姟
-            WrkMast liftWrkMast = wrkMastService.selectLiftWrkMast(wrkMast.getLiftNo());
-            if (liftWrkMast != null) {
-                if (!liftWrkMast.getWrkNo().equals(wrkMast.getWrkNo())) {//鎻愬崌鏈轰换鍔″拰褰撳墠浠诲姟涓嶇浉鍚�
-                    News.taskInfo(wrkMast.getWrkNo(), "{}浠诲姟锛寋}鍙锋彁鍗囨満锛屾彁鍗囨満瀛樺湪鏈畬鎴愪换鍔★紝绂佹娲惧彂", wrkMast.getWrkNo(), wrkMast.getLiftNo());
-                    return false;//褰撳墠鎻愬崌鏈哄瓨鍦ㄦ湭瀹屾垚浠诲姟锛岀瓑寰呬笅涓�娆¤疆璇�
-                }
-            }
-
-            //妫�娴嬫ゼ灞傛槸鍚︽湁绌挎杞�
+            //妫�娴嬫ゼ灞傛槸鍚︽湁鍙敤绌挎杞�
             boolean checkLevHasShuttle = Utils.checkLevHasShuttle(liftSta.getLev());
             if (!checkLevHasShuttle) {
                 if (wrkMast.getShuttleNo() != null) {
@@ -737,24 +655,69 @@
                 return false;
             }
 
+            Integer liftNo = wrkMast.getLiftNo();
+            if (liftNo == null) {
+                //鏈垎閰嶆彁鍗囨満
+                Integer staNo = wrkMast.getSourceStaNo();
+                liftNo = LiftUtils.getConveyorBindLiftNo(staNo);
+                if(liftNo == null) {
+                    News.taskInfo(wrkMast.getWrkNo(), "{}浠诲姟锛屾湭鎵惧埌鍖归厤鐨勬彁鍗囨満", wrkMast.getWrkNo());
+                    return false;
+                }
+
+                //鐢宠鎻愬崌鏈鸿祫婧�
+                boolean applyLift = liftAction.applyLift(liftNo, wrkMast.getWrkNo());
+                if(!applyLift) {
+                    News.taskInfo(wrkMast.getWrkNo(), "{}浠诲姟锛岀敵璇锋彁鍗囨満璧勬簮澶辫触锛岀姝㈠叆搴�", wrkMast.getWrkNo());
+                    return false;
+                }
+                return false;
+            }
+
+            LiftThread liftThread = (LiftThread) SlaveConnection.get(SlaveType.Lift, liftNo);
+            if (liftThread == null) {
+                return false;
+            }
+            LiftProtocol liftProtocol = liftThread.getStatus();
+            if (liftProtocol == null) {
+                return false;
+            }
+            if (!liftThread.isIdle()) {
+                News.taskInfo(wrkMast.getWrkNo(), "{}浠诲姟锛寋}鍙锋彁鍗囨満锛屽繖纰屼腑", wrkMast.getWrkNo(), liftSta.getLiftNo());
+                return false;
+            }
+
+            //鍒ゆ柇鎻愬崌鏈烘槸鍚﹀浜庡叆搴撴ā寮�
+            if (!liftProtocol.getIOModeType().equals(LiftIoModeType.IN)) {
+                News.taskInfo(wrkMast.getWrkNo(), "{}浠诲姟锛屾彁鍗囨満涓嶅浜庡叆搴撴ā寮忥紝绂佹鍏ュ簱", wrkMast.getWrkNo());
+                return false;
+            }
+
+            //璇锋眰涓婄骇绯荤粺锛屾槸鍚﹀厑璁稿叆搴�
+            boolean inMission = LiftUtils.queryInMission(wrkMast.getSourceStaNo(), liftSta.getLiftNo(), wrkMast.getWmsWrkNo());
+            if (!inMission) {
+                News.taskInfo(wrkMast.getWrkNo(), "{}浠诲姟锛屼笂绾х郴缁熶笉鍏佽鍏ュ簱", wrkMast.getWrkNo());
+                return false;
+            }
+
             //鑾峰彇鎻愬崌鏈哄懡浠�
-            List<ForkLiftCommand> liftCommands = forkLiftThread.getPickAndPutCommand(wrkMast.getWrkNo(), wrkMast.getSourceStaNo(), liftSta.getLev());
-            ArrayList<ForkLiftCommand> commands = new ArrayList<>();
-            commands.addAll(liftCommands);
+            LiftCommand liftCommand = liftThread.getPickAndPutCommand(wrkMast.getWrkNo(), wrkMast.getSourceStaNo(), liftSta.getLev());
+            ArrayList<LiftCommand> commands = new ArrayList<>();
+            commands.add(liftCommand);
 
             //鎻愪氦鍒扮嚎绋嬪幓宸ヤ綔
             LiftAssignCommand assignCommand = new LiftAssignCommand();
             assignCommand.setCommands(commands);
-            assignCommand.setLiftNo(wrkMast.getLiftNo().shortValue());
-            assignCommand.setTaskNo(wrkMast.getWrkNo().shortValue());
-            assignCommand.setTaskMode(ForkLiftTaskModeType.PICK_PUT.id.shortValue());
+            assignCommand.setLiftNo(liftNo);
+            assignCommand.setTaskNo(wrkMast.getWrkNo());
+            assignCommand.setTaskMode(ForkLiftTaskModeType.PICK_PUT.id);
 
             wrkMast.setWrkSts(WrkStsType.INBOUND_LIFT_RUN.sts);//鎻愬崌鏈烘惉杩愪腑  1.鐢熸垚鍏ュ簱浠诲姟 ==> 3.鎻愬崌鏈烘惉杩愪腑
             wrkMast.setSystemMsg("");//娓呯┖娑堟伅
             wrkMast.setModiTime(now);
             if (wrkMastService.updateById(wrkMast)) {
                 //涓嬪彂浠诲姟
-                forkLiftAction.assignWork(wrkMast.getLiftNo(), assignCommand);
+                liftAction.assignWork(wrkMast.getLiftNo(), assignCommand);
             }
             return false;
         }
@@ -770,94 +733,112 @@
         //--------------------------------------鎻愬崌鏈哄嚭搴�-----------------------------------------//
         //103.灏忚溅鎼繍瀹屾垚 ==> 104.鎻愬崌鏈烘惉杩愪腑
         if (wrkMast.getWrkSts() == WrkStsType.OUTBOUND_SHUTTLE_RUN_COMPLETE.sts) {
-            ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, wrkMast.getShuttleNo());
-            if (shuttleThread == null) {
-                return false;
-            }
-            ShuttleProtocol shuttleProtocol = shuttleThread.getStatus();
-            if(shuttleProtocol == null) {
-                return false;
-            }
-
             //鑾峰彇婧愮珯
-            ForkLiftStaProtocol liftSta = ForkLiftUtils.getLiftStaByStaNo(wrkMast.getSourceStaNo());
+            LiftStaProtocol liftSta = LiftUtils.getLiftStaByStaNo(wrkMast.getSourceStaNo());
             if (liftSta == null) {
                 News.taskInfo(wrkMast.getWrkNo(), "{}浠诲姟锛屾壘涓嶅埌绔欑偣锛岀姝㈡淳鍙�", wrkMast.getWrkNo());
                 return false;//鎵句笉鍒扮珯鐐�
             }
 
-            if (shuttleProtocol.getCurrentLocNo().equals(liftSta.getLocNo())) {
-                //灏忚溅杩樺湪杈撻�佺珯鐐�
-                //鑾峰彇灏忚溅寰呮満浣�
-                String standbyLocNo = Utils.getShuttleStandbyLocNo(liftSta.getLocNo());
-                if(standbyLocNo == null) {
-                    News.taskInfo(wrkMast.getWrkNo(), "{}浠诲姟锛岃幏鍙栧皬杞﹀緟鏈轰綅澶辫触", wrkMast.getWrkNo());
+            if(wrkMast.getShuttleNo() != null) {
+                ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, wrkMast.getShuttleNo());
+                if (shuttleThread == null) {
                     return false;
                 }
-                //璋冨害灏忚溅鍘诲緟鏈轰綅
-                boolean dispatchShuttle = shuttleDispatchUtils.dispatchShuttle(wrkMast.getWrkNo(), standbyLocNo, wrkMast.getShuttleNo());
-                if (!dispatchShuttle) {
-                    News.taskInfo(wrkMast.getWrkNo(), "{}浠诲姟锛屽皬杞﹀湪杈撻�佺珯鐐硅皟搴﹀皬杞﹂伩璁╁け璐�", wrkMast.getWrkNo());
+                ShuttleProtocol shuttleProtocol = shuttleThread.getStatus();
+                if(shuttleProtocol == null) {
                     return false;
                 }
+
+                if (shuttleProtocol.getCurrentLocNo().equals(liftSta.getLocNo())) {
+                    //灏忚溅杩樺湪杈撻�佺珯鐐�
+                    //鑾峰彇灏忚溅寰呮満浣�
+                    String standbyLocNo = Utils.getShuttleStandbyLocNo(liftSta.getLocNo());
+                    if (standbyLocNo == null) {
+                        News.taskInfo(wrkMast.getWrkNo(), "{}浠诲姟锛岃幏鍙栧皬杞﹀緟鏈轰綅澶辫触", wrkMast.getWrkNo());
+                        return false;
+                    }
+                    //璋冨害灏忚溅鍘诲緟鏈轰綅
+                    boolean dispatchShuttle = shuttleDispatchUtils.dispatchShuttle(wrkMast.getWrkNo(), standbyLocNo, wrkMast.getShuttleNo());
+                    if (!dispatchShuttle) {
+                        News.taskInfo(wrkMast.getWrkNo(), "{}浠诲姟锛屽皬杞﹀湪杈撻�佺珯鐐硅皟搴﹀皬杞﹂伩璁╁け璐�", wrkMast.getWrkNo());
+                        return false;
+                    }
+                } else {
+                    //灏忚溅宸蹭笉鍦ㄨ緭閫佺珯鐐逛綅缃紝閲婃斁灏忚溅
+                    wrkMast.setShuttleNo(null);//閲婃斁灏忚溅
+                    wrkMast.setModiTime(new Date());
+                    wrkMastService.updateById(wrkMast);
+                    return false;
+                }
+                return false;
             }
 
             if (liftSta.getHasCar()) {
-                News.taskInfo(wrkMast.getWrkNo(), "{}浠诲姟锛寋}绔欑偣瀛樺湪灏忚溅锛岀姝㈡淳鍙�", wrkMast.getWrkNo(), liftSta.getStaNo());
+                News.taskInfo(wrkMast.getWrkNo(), "{}浠诲姟锛寋}绔欑偣瀛樺湪灏忚溅锛岀姝㈡淳鍙�", wrkMast.getWrkNo(), liftSta.getSiteId());
                 return false;
             }
 
             if (!liftSta.getHasTray()) {
-                News.taskInfo(wrkMast.getWrkNo(), "{}浠诲姟锛寋}绔欑偣鏃犳墭鐩橈紝绂佹娲惧彂", wrkMast.getWrkNo(), liftSta.getStaNo());
+                News.taskInfo(wrkMast.getWrkNo(), "{}浠诲姟锛寋}绔欑偣鏃犳墭鐩橈紝绂佹娲惧彂", wrkMast.getWrkNo(), liftSta.getSiteId());
                 return false;
             }
 
-            ForkLiftThread forkLiftThread = (ForkLiftThread) SlaveConnection.get(SlaveType.ForkLift, liftSta.getLiftNo());
-            if (forkLiftThread == null) {
+            Integer liftNo = wrkMast.getLiftNo();
+            if (liftNo == null) {
+                //鏈垎閰嶆彁鍗囨満
+                Integer staNo = wrkMast.getStaNo();
+                liftNo = ForkLiftUtils.getConveyorBindLiftNo(staNo);
+                if(liftNo == null) {
+                    News.taskInfo(wrkMast.getWrkNo(), "{}浠诲姟锛屾湭鎵惧埌鍖归厤鐨勬彁鍗囨満", wrkMast.getWrkNo());
+                    return false;
+                }
+                //鐢宠鎻愬崌鏈鸿祫婧�
+                boolean applyLift = liftAction.applyLift(liftSta.getLiftNo(), wrkMast.getWrkNo());
+                if(!applyLift) {
+                    News.taskInfo(wrkMast.getWrkNo(), "{}浠诲姟锛岀敵璇锋彁鍗囨満璧勬簮澶辫触锛岀姝㈡墽琛屽嚭搴�", wrkMast.getWrkNo());
+                    return false;
+                }
                 return false;
             }
-            ForkLiftProtocol forkLiftProtocol = forkLiftThread.getStatus();
-            if (forkLiftProtocol == null) {
+
+            LiftThread liftThread = (LiftThread) SlaveConnection.get(SlaveType.Lift, liftNo);
+            if (liftThread == null) {
                 return false;
             }
-            if (!forkLiftThread.isIdle()) {
+            LiftProtocol liftProtocol = liftThread.getStatus();
+            if (liftProtocol == null) {
+                return false;
+            }
+            if (!liftThread.isIdle()) {
                 News.taskInfo(wrkMast.getWrkNo(), "{}浠诲姟锛寋}鍙锋彁鍗囨満锛屽繖纰屼腑", wrkMast.getWrkNo(), liftSta.getLiftNo());
                 return false;
             }
 
             //鍒ゆ柇鎻愬崌鏈烘槸鍚﹀浜庡嚭搴撴ā寮�
-            if (!forkLiftProtocol.getIOModeType().equals(ForkLiftIoModeType.OUT)) {
+            if (!liftProtocol.getIOModeType().equals(LiftIoModeType.OUT)) {
                 News.taskInfo(wrkMast.getWrkNo(), "{}浠诲姟锛屾彁鍗囨満涓嶅浜庡嚭搴撴ā寮忥紝绂佹鍑哄簱", wrkMast.getWrkNo());
                 return false;
             }
 
-            //鍒ゆ柇鎻愬崌鏈烘槸鍚︽湁鍏朵粬浠诲姟
-            WrkMast liftWrkMast = wrkMastService.selectLiftWrkMast(wrkMast.getLiftNo());
-            if (liftWrkMast != null) {
-                if (!liftWrkMast.getWrkNo().equals(wrkMast.getWrkNo())) {//鎻愬崌鏈轰换鍔″拰褰撳墠浠诲姟涓嶇浉鍚�
-                    News.taskInfo(wrkMast.getWrkNo(), "{}浠诲姟锛寋}鍙锋彁鍗囨満锛屾彁鍗囨満瀛樺湪鏈畬鎴愪换鍔★紝绂佹娲惧彂", wrkMast.getWrkNo(), wrkMast.getLiftNo());
-                    return false;//褰撳墠鎻愬崌鏈哄瓨鍦ㄦ湭瀹屾垚浠诲姟锛岀瓑寰呬笅涓�娆¤疆璇�
-                }
-            }
-
             //璇锋眰涓婄骇绯荤粺锛屾槸鍚﹀厑璁稿嚭搴�
-            boolean outMission = ForkLiftUtils.queryOutMission(wrkMast.getStaNo());
+            boolean outMission = LiftUtils.queryOutMission(wrkMast.getStaNo());
             if (!outMission) {
                 News.taskInfo(wrkMast.getWrkNo(), "{}浠诲姟锛屼笂绾х郴缁熶笉鍏佽鍑哄簱", wrkMast.getWrkNo());
                 return false;
             }
 
             //鑾峰彇鎻愬崌鏈哄懡浠�
-            List<ForkLiftCommand> liftCommands = forkLiftThread.getPickAndPutCommand(wrkMast.getWrkNo(), liftSta.getLev(), wrkMast.getStaNo());
-            ArrayList<ForkLiftCommand> commands = new ArrayList<>();
-            commands.addAll(liftCommands);
+            LiftCommand liftCommand = liftThread.getPickAndPutCommand(wrkMast.getWrkNo(), liftSta.getLev(), wrkMast.getStaNo());
+            ArrayList<LiftCommand> commands = new ArrayList<>();
+            commands.add(liftCommand);
 
             //鎻愪氦鍒扮嚎绋嬪幓宸ヤ綔
             LiftAssignCommand assignCommand = new LiftAssignCommand();
             assignCommand.setCommands(commands);
-            assignCommand.setLiftNo(wrkMast.getLiftNo().shortValue());
-            assignCommand.setTaskNo(wrkMast.getWrkNo().shortValue());
-            assignCommand.setTaskMode(ForkLiftTaskModeType.PICK_PUT.id.shortValue());
+            assignCommand.setLiftNo(liftNo);
+            assignCommand.setTaskNo(wrkMast.getWrkNo());
+            assignCommand.setTaskMode(ForkLiftTaskModeType.PICK_PUT.id);
 
             wrkMast.setWrkSts(WrkStsType.OUTBOUND_LIFT_RUN.sts);//鎻愬崌鏈烘惉杩愪腑  103.鐢熸垚鍏ュ簱浠诲姟 ==> 104.鎻愬崌鏈烘惉杩愪腑
             wrkMast.setShuttleNo(null);//閲婃斁灏忚溅
@@ -865,7 +846,7 @@
             wrkMast.setModiTime(new Date());
             if (wrkMastService.updateById(wrkMast)) {
                 //涓嬪彂浠诲姟
-                forkLiftAction.assignWork(wrkMast.getLiftNo(), assignCommand);
+                liftAction.assignWork(wrkMast.getLiftNo(), assignCommand);
             }
             return false;
         }
@@ -873,47 +854,63 @@
     }
 
     /**
-     * 璐у弶鎻愬崌鏈轰换鍔″畬鎴�
+     * 鎻愬崌鏈轰换鍔″畬鎴�
      */
-    public synchronized void forkLiftFinished() {
+    public synchronized void liftFinished() {
         try {
-            for (ForkLiftSlave forkLiftSlave : slaveProperties.getForkLift()) {
+            List<DeviceConfig> liftList = deviceConfigService.selectList(new EntityWrapper<DeviceConfig>()
+                    .eq("device_type", String.valueOf(SlaveType.Lift)));
+            for (DeviceConfig device : liftList) {
                 //鑾峰彇鎻愬崌鏈轰俊鎭�
-                ForkLiftThread forkLiftThread = (ForkLiftThread) SlaveConnection.get(SlaveType.ForkLift, forkLiftSlave.getId());
-                ForkLiftProtocol forkLiftProtocol = forkLiftThread.getStatus();
-                if (forkLiftProtocol == null) {
+                LiftThread liftThread = (LiftThread) SlaveConnection.get(SlaveType.Lift, device.getDeviceNo());
+                if(liftThread == null) {
+                    continue;
+                }
+                LiftProtocol liftProtocol = liftThread.getStatus();
+                if (liftProtocol == null) {
                     continue;
                 }
 
                 //鎻愬崌鏈轰负绛夊緟纭涓旂┖闂�
-                if (forkLiftProtocol.getProtocolStatus() == ForkLiftProtocolStatusType.WAITING.id
-                        && forkLiftProtocol.getWrkNo() != 0
+                if (liftProtocol.getProtocolStatus() == LiftProtocolStatusType.WAITING.id
+                        && liftProtocol.getTaskNo() != 0
                 ) {
                     //灏嗕换鍔℃。鏍囪涓哄畬鎴�
-                    WrkMast wrkMast = wrkMastService.selectByWorkNo(forkLiftProtocol.getWrkNo());
+                    WrkMast wrkMast = wrkMastService.selectByWorkNo(liftProtocol.getTaskNo());
                     if (wrkMast != null) {
                         if (wrkMast.getWrkSts() == WrkStsType.INBOUND_LIFT_RUN.sts) {
                             //3.鎻愬崌鏈烘惉杩愪腑 ==> 4.鎻愬崌鏈烘惉杩愬畬鎴�
                             wrkMast.setWrkSts(WrkStsType.INBOUND_LIFT_RUN_COMPLETE.sts);
                             wrkMast.setLiftNo(null);//閲婃斁鎻愬崌鏈�
-                            forkLiftThread.setSyncTaskNo(0);
+                        }else if (wrkMast.getWrkSts() == WrkStsType.MOVE_NEARBY_COMPLETE.sts) {
+                            //303.灏忚溅绉诲姩鑷宠繎鐐瑰畬鎴� -- 璋冨害鎻愬崌鏈哄埌灏忚溅灞�
                         } else if (wrkMast.getWrkSts() == WrkStsType.OUTBOUND_LIFT_RUN.sts) {
-                            //104.鎻愬崌鏈烘惉杩愪腑 ==> 109.鍑哄簱瀹屾垚
+                            //304.鎻愬崌鏈烘惉杩愪腑 ==> 109.鍑哄簱瀹屾垚
                             wrkMast.setWrkSts(WrkStsType.COMPLETE_OUTBOUND.sts);
                             wrkMast.setLiftNo(null);//閲婃斁鎻愬崌鏈�
-                            forkLiftThread.setSyncTaskNo(0);
                         } else if (wrkMast.getWrkSts() == WrkStsType.MOVE_LIFT_RUN.sts) {
                             //306.鎻愬崌鏈烘惉杩愪腑 ==> 307.鎻愬崌鏈烘惉杩愬畬鎴�
                             wrkMast.setWrkSts(WrkStsType.MOVE_LIFT_RUN_COMPLETE.sts);
-                            forkLiftThread.setSyncTaskNo(0);
+                        } else {
+                            News.error("鎻愬崌鏈虹‘璁ゅけ璐ワ紝鎻愬崌鏈哄彿={}锛屽伐浣滃彿={}", liftProtocol.getLiftNo(), liftProtocol.getTaskNo());
+                            return;
                         }
 
                         wrkMast.setModiTime(new Date());
                         if (wrkMastService.updateById(wrkMast)) {
-                            forkLiftThread.reset();
-                            News.info("鎻愬崌鏈哄凡纭涓斾换鍔″畬鎴愮姸鎬併�傛彁鍗囨満鍙�={}", forkLiftProtocol.getLiftNo());
+                            liftThread.reset();
+                            News.info("鎻愬崌鏈哄凡纭涓斾换鍔″畬鎴愮姸鎬併�傛彁鍗囨満鍙�={}", liftProtocol.getLiftNo());
                         } else {
-                            News.error("鎻愬崌鏈哄凡纭涓斾换鍔″畬鎴愮姸鎬�,澶嶄綅澶辫触锛屼絾鏈壘鍒板伐浣滄。銆傛彁鍗囨満鍙�={}锛屽伐浣滃彿={}", forkLiftProtocol.getLiftNo(), forkLiftProtocol.getWrkNo());
+                            News.error("鎻愬崌鏈哄凡纭涓斾换鍔″畬鎴愮姸鎬�,澶嶄綅澶辫触锛屼絾鏈壘鍒板伐浣滄。銆傛彁鍗囨満鍙�={}锛屽伐浣滃彿={}", liftProtocol.getLiftNo(), liftProtocol.getTaskNo());
+                        }
+                    }else {
+                        boolean checkPreviewDispatchForkLift = commonService.checkWorkNoContainMk(liftProtocol.getTaskNo(), WrkIoType.PREVIEW_LIFT_MOVE.id);
+                        if (checkPreviewDispatchForkLift) {
+                            //灞炰簬鎻愬崌鏈洪璋冨害绉诲姩浠诲姟
+                            //鏃犲伐浣滄。鏀拺锛岀洿鎺ョ‘璁ゅ畬鎴�
+                            liftThread.setSyncTaskNo(0);
+                            liftThread.reset();
+                            News.info("宸茬‘璁ゆ彁鍗囨満棰勮皟搴︾Щ鍔ㄤ换鍔°�傛彁鍗囨満鍙�={}", liftProtocol.getLiftNo());
                         }
                     }
                 }
@@ -940,9 +937,11 @@
      */
     private void recShuttleErr() {
         Date now = new Date();
-        for (ShuttleSlave shuttleSlave : slaveProperties.getShuttle()) {
+        List<DeviceConfig> shuttleList = deviceConfigService.selectList(new EntityWrapper<DeviceConfig>()
+                .eq("device_type", String.valueOf(SlaveType.Shuttle)));
+        for (DeviceConfig device : shuttleList) {
             // 鑾峰彇鍥涘悜绌挎杞︿俊鎭�
-            ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, shuttleSlave.getId());
+            ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, device.getDeviceNo());
             if (shuttleThread == null) {
                 continue;
             }
@@ -953,7 +952,7 @@
 
             if (shuttleProtocol.getTaskNo() != 0) {
                 //鏈変换鍔�
-                BasShuttleErrLog latest = basShuttleErrLogService.findLatestByTaskNo(shuttleSlave.getId(), shuttleProtocol.getTaskNo());
+                BasShuttleErrLog latest = basShuttleErrLogService.findLatestByTaskNo(device.getDeviceNo(), shuttleProtocol.getTaskNo());
                 // 鏈夊紓甯�
                 if (latest == null) {
                     if (shuttleProtocol.getErrorCode() != null && Integer.parseInt(shuttleProtocol.getErrorCode()) != 0) {
@@ -971,7 +970,7 @@
                                 null,    // 缁撴潫鏃堕棿
                                 wrkMast.getWrkSts(),    // 宸ヤ綔鐘舵��
                                 wrkMast.getIoType(),    // 鍏ュ嚭搴撶被鍨�
-                                shuttleSlave.getId(),    // 鍥涘悜绌挎杞�
+                                device.getDeviceNo(),    // 鍥涘悜绌挎杞�
                                 null,    // plc
                                 wrkMast.getLocNo(),    // 鐩爣搴撲綅
                                 wrkMast.getStaNo(),    // 鐩爣绔�
@@ -989,7 +988,7 @@
                                 JSON.toJSONString(shuttleProtocol)    // 绯荤粺鐘舵�佹暟鎹�
                         );
                         if (!basShuttleErrLogService.insert(basShuttleErrLog)) {
-                            News.error("鍥涘悜绌挎杞lc寮傚父璁板綍澶辫触 ===>> [id:{}] [error:{}]", shuttleSlave.getId(), errName);
+                            News.error("鍥涘悜绌挎杞lc寮傚父璁板綍澶辫触 ===>> [id:{}] [error:{}]", device.getDeviceNo(), errName);
                         }
                     }
                 } else {
@@ -999,7 +998,7 @@
                         latest.setUpdateTime(now);
                         latest.setStatus(2);
                         if (!basShuttleErrLogService.updateById(latest)) {
-                            News.error("鍥涘悜绌挎杞lc寮傚父璁板綍淇澶辫触 ===>> [id:{}] [errLogId:{}]", shuttleSlave.getId(), latest.getId());
+                            News.error("鍥涘悜绌挎杞lc寮傚父璁板綍淇澶辫触 ===>> [id:{}] [errLogId:{}]", device.getDeviceNo(), latest.getId());
                         }
                     }
                 }
@@ -1012,9 +1011,11 @@
      */
     private void recLiftErr() {
         Date now = new Date();
-        for (ForkLiftSlave forkLiftSlave : slaveProperties.getForkLift()) {
+        List<DeviceConfig> forkliftList = deviceConfigService.selectList(new EntityWrapper<DeviceConfig>()
+                .eq("device_type", String.valueOf(SlaveType.ForkLift)));
+        for (DeviceConfig device : forkliftList) {
             // 鑾峰彇鎻愬崌鏈轰俊鎭�
-            ForkLiftThread forkLiftThread = (ForkLiftThread) SlaveConnection.get(SlaveType.ForkLift, forkLiftSlave.getId());
+            ForkLiftThread forkLiftThread = (ForkLiftThread) SlaveConnection.get(SlaveType.ForkLift, device.getDeviceNo());
             if (forkLiftThread == null) {
                 continue;
             }
@@ -1025,7 +1026,7 @@
 
             if (forkLiftProtocol.getTaskNo() != 0) {
                 //鏈変换鍔�
-                BasLiftErrLog latest = basLiftErrLogService.findLatestByTaskNo(forkLiftSlave.getId(), forkLiftProtocol.getTaskNo());
+                BasLiftErrLog latest = basLiftErrLogService.findLatestByTaskNo(device.getDeviceNo(), forkLiftProtocol.getTaskNo());
                 // 鏈夊紓甯�
                 if (latest == null) {
                     if (forkLiftProtocol.getErrorCode() != null && forkLiftProtocol.getErrorCode() != 0) {
@@ -1044,7 +1045,7 @@
                                 null,    // 缁撴潫鏃堕棿
                                 wrkMast.getWrkSts(),    // 宸ヤ綔鐘舵��
                                 wrkMast.getIoType(),    // 鍏ュ嚭搴撶被鍨�
-                                forkLiftSlave.getId(),    // 鎻愬崌鏈�
+                                device.getDeviceNo(),    // 鎻愬崌鏈�
                                 null,    // plc
                                 wrkMast.getLocNo(),    // 鐩爣搴撲綅
                                 wrkMast.getStaNo(),    // 鐩爣绔�
@@ -1062,7 +1063,7 @@
                                 JSON.toJSONString(forkLiftProtocol)    // 绯荤粺鐘舵�佹暟鎹�
                         );
                         if (!basLiftErrLogService.insert(basLiftErrLog)) {
-                            News.error("鎻愬崌鏈簆lc寮傚父璁板綍澶辫触 ===>> [id:{}] [error:{}]", forkLiftSlave.getId(), errName);
+                            News.error("鎻愬崌鏈簆lc寮傚父璁板綍澶辫触 ===>> [id:{}] [error:{}]", device.getDeviceNo(), errName);
                         }
                     }
                 } else {
@@ -1072,7 +1073,7 @@
                         latest.setUpdateTime(now);
                         latest.setStatus(2);
                         if (!basLiftErrLogService.updateById(latest)) {
-                            News.error("鎻愬崌鏈簆lc寮傚父璁板綍淇澶辫触 ===>> [id:{}] [errLogId:{}]", forkLiftSlave.getId(), latest.getId());
+                            News.error("鎻愬崌鏈簆lc寮傚父璁板綍淇澶辫触 ===>> [id:{}] [errLogId:{}]", device.getDeviceNo(), latest.getId());
                         }
                     }
                 }
@@ -1085,16 +1086,52 @@
      */
     public synchronized void loopShuttleCharge() {
         try {
-            for (ShuttleSlave shuttle : slaveProperties.getShuttle()) {
+
+            List<BasShuttleCharge> charges = basShuttleChargeService.selectList(new EntityWrapper<BasShuttleCharge>().orderBy("charge_id", true));
+            if (charges.isEmpty()) {
+                return;//鏃犲厖鐢垫々
+            }
+
+            List<DeviceConfig> shuttleList = deviceConfigService.selectList(new EntityWrapper<DeviceConfig>()
+                    .eq("device_type", String.valueOf(SlaveType.Shuttle)));
+            for (DeviceConfig device : shuttleList) {
                 //鑾峰彇鍥涘悜绌挎杞︾嚎绋�
-                ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, shuttle.getId());
+                ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, device.getDeviceNo());
                 ShuttleProtocol shuttleProtocol = shuttleThread.getStatus();
                 if (shuttleProtocol == null) {
                     continue;
                 }
 
                 //鍒ゆ柇褰撳墠灏忚溅鏄惁婊¤冻闇�瑕佸厖鐢佃姹�
-                if (!shuttleThread.isRequireCharge()) {
+                if (shuttleThread.isRequireCharge().equals(ShuttleRequireChargeType.NONE)) {
+                    continue;//鏃犻渶鍏呯數
+                }
+
+                boolean forceCharge = true;
+                if (shuttleThread.isRequireCharge().equals(ShuttleRequireChargeType.SUGGEST_CHARGE)) {
+                    BasShuttle basShuttle = basShuttleService.selectOne(new EntityWrapper<BasShuttle>().eq("shuttle_no", device.getDeviceNo()));
+                    if (basShuttle != null) {
+                        Integer suggestChargeLine = basShuttle.getSuggestChargeLine();
+                        boolean chargeSuggestResult = Integer.parseInt(shuttleProtocol.getBatteryPower()) < suggestChargeLine;
+                        if (chargeSuggestResult) {
+                            //妫�娴嬬郴缁熸槸鍚︽湁浠诲姟
+                            List<WrkMast> wrkMasts = wrkMastService.selectList(new EntityWrapper<WrkMast>().in("io_type", 1, 101, 201));
+                            if (wrkMasts.isEmpty()) {
+                                forceCharge = false;
+                            }else {
+                                continue;
+                            }
+                        }
+                    }
+                }
+
+                WrkMast wrkMast1 = wrkMastService.selectShuttleWorking(shuttleProtocol.getShuttleNo());
+                if (wrkMast1 != null) {
+                    continue;
+                }
+
+                WrkMast wrkMast2 = wrkMastService.selectShuttleHasMoveWorking(shuttleProtocol.getShuttleNo());
+                if (wrkMast2 != null) {
                     continue;
                 }
 
@@ -1105,17 +1142,21 @@
 
                 //灏忚溅鎵�鍦ㄦゼ灞�
                 int lev = Utils.getLev(shuttleProtocol.getCurrentLocNo());
-                ShuttleChargeType shuttleCharge = null;
+                BasShuttleCharge shuttleCharge = null;
 
                 //鎼滅储灏忚溅鎵�鍦ㄦゼ灞傛湁娌℃湁鍏呯數妗�
-                for (ShuttleChargeType chargeType : ShuttleChargeType.values()) {
-                    if (lev != Utils.getLev(chargeType.locNo)) {
+                for (BasShuttleCharge charge : charges) {
+                    if (lev != Utils.getLev(charge.getLocNo())) {
                         continue;//灏忚溅鍜屽厖鐢垫々涓嶅湪鍚屼竴灞�
                     }
 
+                    if (charge.getStatus() == 0) {
+                        continue;//鍏呯數妗╄绂佺敤
+                    }
+
                     //灏忚溅鍜屽厖鐢垫々鍦ㄥ悓涓�灞�
-                    if (wrkMastService.selectChargeWorkingByChargeSta(chargeType.id) == null) {
-                        shuttleCharge = chargeType;
+                    if (wrkMastService.selectChargeWorkingByChargeSta(charge.getChargeId()) == null) {
+                        shuttleCharge = charge;
                         break;
                     }
                 }
@@ -1123,17 +1164,22 @@
                 if (shuttleCharge == null) {
                     //鍚屾ゼ灞傛病鏈夋壘鍒板厖鐢垫々锛屾壘鍙敤鍏呯數妗�
                     //灏忚溅鍚屾ゼ灞傛病鏈夊厖鐢垫々锛屽彧瑕佸厖鐢垫々鍙敤灏辩敓鎴愬厖鐢典换鍔�
-                    for (ShuttleChargeType chargeType : ShuttleChargeType.values()) {
-                        if (wrkMastService.selectChargeWorkingByChargeSta(chargeType.id) == null) {
-                            //鍒ゆ柇褰撳墠鍏呯數妗╂ゼ灞傛槸鍚︽湁灏忚溅锛屽鏈夊皬杞︼紝涓嶅垎閰嶈鍏呯數妗�
-                            int chargeLev = Utils.getLev(chargeType.locNo);//鍏呯數妗╂ゼ灞�
-                            boolean checkLevHasShuttle = Utils.checkLevHasShuttle(chargeLev);//妫�娴嬫ゼ灞傛槸鍚︽湁绌挎杞�
-                            if (checkLevHasShuttle) {
-                                //褰撳墠鍏呯數妗╂ゼ灞傛湁绌挎杞︼紝涓嶅垎閰嶈鍏呯數妗�
+                    for (BasShuttleCharge charge : charges) {
+                        if (wrkMastService.selectChargeWorkingByChargeSta(charge.getChargeId()) == null) {
+                            //鍒ゆ柇褰撳墠鍏呯數妗╂槸鍚︽湁灏忚溅锛屽鏈夊皬杞︼紝涓嶅垎閰嶈鍏呯數妗�
+                            ArrayList<String> locs = new ArrayList<>();
+                            locs.add(charge.getLocNo());
+                            Integer checkHasShuttle = Utils.checkGroupLocHasShuttle(locs);
+                            if(checkHasShuttle != null) {
+                                //褰撳墠鍏呯數妗╂湁绌挎杞︼紝涓嶅垎閰嶈鍏呯數妗�
                                 continue;
                             }
 
-                            shuttleCharge = chargeType;
+                            if (charge.getStatus() == 0) {
+                                continue;//鍏呯數妗╄绂佺敤
+                            }
+
+                            shuttleCharge = charge;
                             break;
                         }
                     }
@@ -1143,23 +1189,23 @@
                     continue;
                 }
 
-                String chargeLocNo = shuttleCharge.locNo;
+                String chargeLocNo = shuttleCharge.getLocNo();
                 wrkMast = new WrkMast();
-                wrkMast.setMk(String.valueOf(shuttleCharge.id));
+                wrkMast.setMk(String.valueOf(shuttleCharge.getChargeId()));
                 wrkMast.setWrkNo(commonService.getWorkNo(WrkIoType.SHUTTLE_CHARGE.id));
                 wrkMast.setWrkSts(WrkStsType.NEW_CHARGE.sts);
                 wrkMast.setIoType(WrkIoType.SHUTTLE_CHARGE.id);//300.鍏呯數
                 wrkMast.setIoPri((double) 999);
                 wrkMast.setLocNo(chargeLocNo);
-                wrkMast.setShuttleNo(shuttle.getId());
-                wrkMast.setMemo("charge");
+                wrkMast.setShuttleNo(device.getDeviceNo());
+                wrkMast.setMemo(forceCharge ? "forceCharge" : "suggestCharge");
                 wrkMast.setAppeTime(new Date());
                 if (!wrkMastService.insert(wrkMast)) {
-                    News.error("淇濆瓨{}鍙峰洓鍚戠┛姊溅鍏呯數浠诲姟澶辫触!!!", shuttle.getId());
+                    News.error("淇濆瓨{}鍙峰洓鍚戠┛姊溅鍏呯數浠诲姟澶辫触!!!", device.getDeviceNo());
                     continue;
                 }
 
-                News.info("淇濆瓨{}鍙峰洓鍚戠┛姊溅鍏呯數浠诲姟鎴愬姛!!!", shuttle.getId());
+                News.info("淇濆瓨{}鍙峰洓鍚戠┛姊溅鍏呯數浠诲姟鎴愬姛!!!", device.getDeviceNo());
             }
         } catch (Exception e) {
             e.printStackTrace();
@@ -1172,8 +1218,10 @@
     public synchronized void executeShuttleCharge() {
         try {
             //鏌ヨ灏忚溅鍏呯數浠诲姟
-            for (ShuttleSlave shuttle : slaveProperties.getShuttle()) {
-                WrkMast wrkMast = wrkMastService.selectChargeWorking(shuttle.getId());
+            List<DeviceConfig> shuttleList = deviceConfigService.selectList(new EntityWrapper<DeviceConfig>()
+                    .eq("device_type", String.valueOf(SlaveType.Shuttle)));
+            for (DeviceConfig device : shuttleList) {
+                WrkMast wrkMast = wrkMastService.selectChargeWorking(device.getDeviceNo());
                 if(wrkMast == null) {
                     continue;
                 }
@@ -1222,7 +1270,7 @@
                 return false;
             }
 
-            if (shuttleProtocol.getCurrentLocNo().equals(wrkMast.getLocNo())) {
+            if (wrkMast.getLocNo().equals(shuttleProtocol.getCurrentLocNo())) {
                 //灏忚溅鍦ㄥ厖鐢垫々浣嶇疆
                 wrkMast.setWrkSts(WrkStsType.CHARGE_SHUTTLE_RUN_COMPLETE.sts);
                 wrkMast.setModiTime(new Date());
@@ -1264,7 +1312,7 @@
                 return false;
             }
 
-            if (!shuttleProtocol.getCurrentLocNo().equals(wrkMast.getLocNo())) {
+            if (!wrkMast.getLocNo().equals(shuttleProtocol.getCurrentLocNo())) {
                 return false;
             }
 
@@ -1294,13 +1342,13 @@
             ShuttleAssignCommand assignCommand = new ShuttleAssignCommand();
             assignCommand.setShuttleNo(shuttleProtocol.getShuttleNo());//鍥涘悜绌挎杞﹀彿
             assignCommand.setTaskNo(wrkMast.getWrkNo());//浠诲姟鍙�
-            assignCommand.setTaskMode(ShuttleTaskModeType.CHARGE.id);//鍑哄簱妯″紡
+            assignCommand.setTaskMode(ShuttleTaskModeType.CHARGE_ON.id);//鍏呯數寮�
             assignCommand.setSourceLocNo(shuttleProtocol.getCurrentLocNo());//婧愬簱浣�(灏忚溅褰撳墠浣嶇疆)
 
             List<ShuttleCommand> commands = shuttleOperaUtils.getShuttleChargeCommand(assignCommand, shuttleThread, true);
             assignCommand.setCommands(commands);//杩愯鍛戒护
 
-            wrkMast.setWrkSts(WrkStsType.CHARGE_SHUTTLE_WORKING.sts);
+            wrkMast.setWrkSts(WrkStsType.CHARGE_SHUTTLE_START_CHARGING.sts);
             wrkMast.setModiTime(new Date());
             if (!wrkMastService.updateById(wrkMast)) {
                 return false;
@@ -1317,7 +1365,7 @@
 
     //灏忚溅鍋滄鍏呯數
     private synchronized boolean executeShuttleChargeStepStopCharge(WrkMast wrkMast) {
-        if (wrkMast.getWrkSts() == WrkStsType.CHARGE_SHUTTLE_WORKING.sts) {
+        if (wrkMast.getWrkSts() == WrkStsType.CHARGE_SHUTTLE_CHARGING.sts) {
             ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, wrkMast.getShuttleNo());
             if (shuttleThread == null) {
                 return false;
@@ -1327,7 +1375,21 @@
                 return false;
             }
 
-            if (!shuttleThread.isChargingCompleted()) {
+            boolean stopCharge = false;
+            if (wrkMast.getMemo().equals("suggestChargeTaskStop")) {
+                stopCharge = true;
+            }else {
+                if (shuttleThread.isChargingCompleted()) {
+                    stopCharge = true;
+                }
+            }
+
+            if (!stopCharge) {
+                return false;
+            }
+
+            Object limitObj = redisUtil.get(RedisKeyType.TASK_RUN_LIMIT.key + wrkMast.getWrkNo());
+            if (limitObj != null) {
                 return false;
             }
 
@@ -1335,7 +1397,7 @@
             ShuttleAssignCommand assignCommand = new ShuttleAssignCommand();
             assignCommand.setShuttleNo(shuttleProtocol.getShuttleNo());//鍥涘悜绌挎杞﹀彿
             assignCommand.setTaskNo(wrkMast.getWrkNo());//浠诲姟鍙�
-            assignCommand.setTaskMode(ShuttleTaskModeType.CHARGE.id);//鍑哄簱妯″紡
+            assignCommand.setTaskMode(ShuttleTaskModeType.CHARGE_OFF.id);//鍏呯數鍏�
             assignCommand.setSourceLocNo(shuttleProtocol.getCurrentLocNo());//婧愬簱浣�(灏忚溅褰撳墠浣嶇疆)
 
             List<ShuttleCommand> commands = shuttleOperaUtils.getShuttleChargeCommand(assignCommand, shuttleThread, false);
@@ -1343,6 +1405,7 @@
 
             //涓嬪彂浠诲姟
             shuttleAction.assignWork(shuttleProtocol.getShuttleNo(), assignCommand);
+            redisUtil.set(RedisKeyType.TASK_RUN_LIMIT.key + wrkMast.getWrkNo(), "limit", 10);
             return false;
         }
         return true;
@@ -1350,7 +1413,7 @@
 
     //灏忚溅绂诲紑鍏呯數妗�
     private synchronized boolean executeShuttleChargeStepLeaveCharge(WrkMast wrkMast) {
-        if (wrkMast.getWrkSts() == WrkStsType.CHARGE_SHUTTLE_COMPLETE.sts) {
+        if (wrkMast.getWrkSts() == WrkStsType.CHARGE_SHUTTLE_CHARGING_COMPLETE.sts) {
             ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, wrkMast.getShuttleNo());
             if (shuttleThread == null) {
                 return false;
@@ -1360,13 +1423,22 @@
                 return false;
             }
 
-            ShuttleChargeType chargeType = ShuttleChargeType.get(Integer.parseInt(wrkMast.getMk()));
-            if(chargeType == null) {
+            BasShuttleCharge basShuttleCharge = basShuttleChargeService.selectOne(new EntityWrapper<BasShuttleCharge>().eq("charge_id", wrkMast.getMk()));
+            if(basShuttleCharge == null) {
+                return false;
+            }
+
+            //妫�娴嬮殰纰嶇墿杞�
+            int checkObstacle = shuttleOperaUtils.checkObstacle(basShuttleCharge.getWaitLocNo(), new ArrayList<Integer>() {{
+                add(shuttleProtocol.getShuttleNo());
+            }}, new ArrayList<>());
+            if (checkObstacle > 0) {
+                News.info("{}浠诲姟锛岄伩闅滆寖鍥存湁灏忚溅锛岀瓑寰呴殰纰嶅皬杞﹁皟绂讳腑", wrkMast.getWrkNo());
                 return false;
             }
 
             //璋冨害灏忚溅鍘诲緟鏈轰綅
-            boolean dispatched = shuttleDispatchUtils.dispatchShuttle(wrkMast.getWrkNo(), chargeType.waitLocNo, wrkMast.getShuttleNo());
+            boolean dispatched = shuttleDispatchUtils.dispatchShuttle(wrkMast.getWrkNo(), basShuttleCharge.getWaitLocNo(), wrkMast.getShuttleNo());
             if (!dispatched) {
                 return false;
             }
@@ -1389,8 +1461,13 @@
             //鏌ヨ灏忚溅绉诲簱浠诲姟
             List<WrkMast> wrkMasts = wrkMastService.selectShuttleMoveWrk();
             for (WrkMast wrkMast : wrkMasts) {
-                boolean stepMoveSta = this.shuttleMoveExecuteStepMoveSta(wrkMast);//灏忚溅绉诲姩鍒扮珯鐐�
-                if (!stepMoveSta) {
+                boolean stepMoveNearby = this.shuttleMoveExecuteStepMoveNearby(wrkMast);//灏忚溅绉诲姩鍒拌繎鐐�
+                if (!stepMoveNearby) {
+                    continue;
+                }
+
+                boolean stepMoveInLift = this.shuttleMoveExecuteStepMoveInLift(wrkMast);//灏忚溅杩佸叆鎻愬崌鏈轰腑
+                if (!stepMoveInLift) {
                     continue;
                 }
 
@@ -1416,15 +1493,15 @@
     }
 
     /**
-     * 灏忚溅杩佺Щ-灏忚溅绉诲姩鍒扮珯鐐�
+     * 灏忚溅杩佺Щ-灏忚溅绉诲姩鍒拌繎鐐逛腑
      * 濡傞渶涓绘柟娉曟墽琛宑ontinue锛岃杩斿洖false
      * ps:杩斿洖鍊紅rue骞朵笉浠ｈ〃璇ユ柟娉曟墽琛屾垚鍔燂紝杩斿洖鍊间粎鍋氭爣璁扮敤浜庝富鏂规硶鏄惁鎵цcontinue
      */
-    private boolean shuttleMoveExecuteStepMoveSta(WrkMast wrkMast) {
-        //--------------------------------------灏忚溅绉诲姩鑷崇珯鐐�-----------------------------------------//
+    private boolean shuttleMoveExecuteStepMoveNearby(WrkMast wrkMast) {
+        //--------------------------------------灏忚溅绉诲姩鍒拌繎鐐逛腑-----------------------------------------//
         Date now = new Date();
 
-        //灏忚溅绉诲姩鑷崇珯鐐�  301.鐢熸垚灏忚溅绉诲簱浠诲姟 ==> 302.灏忚溅绉诲姩鑷崇珯鐐逛腑
+        //灏忚溅绉诲姩鍒拌繎鐐�  301.鐢熸垚灏忚溅绉诲簱浠诲姟 ==> 302.灏忚溅绉诲姩鑷崇珯鐐逛腑
         if (wrkMast.getWrkSts() == WrkStsType.NEW_MOVE.sts) {
             //鑾峰彇鍥涘悜绌挎杞︾嚎绋�
             ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, wrkMast.getShuttleNo());
@@ -1453,60 +1530,199 @@
                 return false;
             }
 
-            //鑾峰彇婧愯緭閫佺珯
-            ForkLiftStaProtocol liftSta = ForkLiftUtils.getLiftStaByStaNo(wrkMast.getSourceStaNo());
-            if (liftSta == null) {
-                return false;//鎵句笉鍒扮珯鐐�
+            //鎼滅储鏈�杩戜笖鏃犳晠闅滄彁鍗囨満
+            LiftStaProtocol recentLiftStation = liftDispatchUtils.getRecentLiftStation(shuttleProtocol.getShuttleNo(), Utils.getLev(shuttleProtocol.getCurrentLocNo()));
+            if(recentLiftStation == null) {
+                News.info("{}鍙峰皬杞︼紝{}鐩爣搴撲綅锛屾病鏈夊彲鐢ㄧ┖闂茶緭閫佺珯鐐�", shuttleProtocol.getShuttleNo(), wrkMast.getLocNo());
+                return false;
             }
 
-            //鍒ゆ柇鎻愬崌鏈烘槸鍚︽湁鍏朵粬浠诲姟(璇ヤ换鍔￠渶瑕佹崲灞傚繀椤绘彁鍓嶇嫭鍗犳彁鍗囨満)
-            WrkMast liftWrkMast = wrkMastService.selectLiftWrkMast(liftSta.getLiftNo());
-            if (liftWrkMast != null) {
-                News.taskInfo(wrkMast.getWrkNo(), "{}浠诲姟锛寋}鍙锋彁鍗囨満锛屾彁鍗囨満瀛樺湪鏈畬鎴愪换鍔★紝绂佹娲惧彂", wrkMast.getWrkNo(), liftSta.getLiftNo());
-                return false;//褰撳墠鎻愬崌鏈哄瓨鍦ㄦ湭瀹屾垚浠诲姟锛岀瓑寰呬笅涓�娆¤疆璇�
+            LiftStaProtocol targetLiftSta = LiftUtils.getLiftStaByLev(recentLiftStation.getLiftNo(), Utils.getLev(wrkMast.getLocNo()));
+            if(targetLiftSta == null) {
+                return false;
             }
 
-            //*************灏濊瘯閿佸畾鐩爣绔欒矾寰�***************
-            List<NavigateNode> targetNodes = ForkLiftUtils.getLiftStaNodes(wrkMast.getStaNo());
-            if (targetNodes == null) {
-                return false;//鏈幏鍙栧埌鑺傜偣
+            //璁＄畻杩戠偣浣嶇疆
+            String endLocation = navigateUtils.calcEndLocation(shuttleProtocol.getCurrentLocNo(), recentLiftStation.getLocNo(), NavigationMapType.getMapTypes(NavigationMapType.NORMAL), null, null, 1);
+            if (endLocation == null) {
+                News.taskInfo(wrkMast.getWrkNo(), "{}浠诲姟锛屽皬杞﹁繎鐐逛綅缃绠楀け璐�", wrkMast.getWrkNo());
+                return false;
             }
-            boolean checkPathIsAvailable = navigateUtils.checkPathIsAvailable(targetNodes, shuttleProtocol.getShuttleNo(), Utils.getLev(wrkMast.getLocNo()));
-            if (!checkPathIsAvailable) {
-                News.info("{}浠诲姟锛寋}灏忚溅锛岀洰鏍囩珯鐐硅矾寰勮鍗犵敤锛岀姝㈡淳鍙�", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
-                return false;//妫�娴嬬洰鏍囩珯鐐硅矾寰勬槸鍚︽湭琚崰鐢�
+
+            //灏忚溅宸插湪杩戠偣浣嶇疆鏃犻渶鍓嶅線
+            if (shuttleProtocol.getCurrentLocNo().equals(endLocation)) {
+                wrkMast.setWrkSts(WrkStsType.MOVE_NEARBY_COMPLETE.sts);//灏忚溅绉诲姩鍒版彁鍗囨満涓�  301.鐢熸垚灏忚溅绉诲簱浠诲姟 ==> 303.灏忚溅绉诲姩鑷宠繎鐐瑰畬鎴�
+                wrkMast.setSourceStaNo(recentLiftStation.getSiteId());
+                wrkMast.setStaNo(targetLiftSta.getSiteId());
+                wrkMast.setModiTime(now);
+                wrkMast.setSystemMsg("");//娓呯┖娑堟伅
+                wrkMastService.updateById(wrkMast);
+                return true;
             }
-            //灏濊瘯閿佸畾鐩爣绔欒矾寰�
-            boolean result2 = navigateMapUtils.writeNavigateNodeToRedisMap(Utils.getLev(wrkMast.getLocNo()), shuttleProtocol.getShuttleNo(), targetNodes, true);//鎵�浣跨敤鐨勮矾寰勮繘琛岄攣瀹氱鐢�
-            if (!result2) {
-                News.info("{}浠诲姟锛寋}灏忚溅锛岃矾寰勯攣瀹氬け璐ワ紝绂佹娲惧彂", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
-                return false;//璺緞閿佸畾澶辫触
-            }
-            //*************灏濊瘯閿佸畾鐩爣绔欒矾寰�***************
 
             ShuttleAssignCommand assignCommand = new ShuttleAssignCommand();
             assignCommand.setShuttleNo(shuttleProtocol.getShuttleNo()); // 鍥涘悜绌挎杞︾紪鍙�
             assignCommand.setTaskMode(ShuttleTaskModeType.MOVE_LOC_NO.id);//灏忚溅绉诲簱浠诲姟
             assignCommand.setTaskNo(wrkMast.getWrkNo());//浠诲姟鍙�
+            assignCommand.setSourceLocNo(shuttleProtocol.getCurrentLocNo());//婧愬簱浣�
+            assignCommand.setLocNo(endLocation);
             assignCommand.setAuto(true);//鑷姩妯″紡
 
-            //鑾峰彇灏忚溅鍒拌緭閫佺珯鐐硅璧板懡浠�
-            List<ShuttleCommand> commands = shuttleOperaUtils.getStartToTargetCommands(shuttleProtocol.getCurrentLocNo(), liftSta.getLocNo(), NavigationMapType.NORMAL.id, assignCommand, shuttleThread);
+            //鑾峰彇灏忚溅鍒拌繎鐐硅璧板懡浠�
+            List<ShuttleCommand> commands = shuttleOperaUtils.getStartToTargetCommands(shuttleProtocol.getCurrentLocNo(), endLocation, NavigationMapType.getMapTypes(NavigationMapType.NORMAL, NavigationMapType.SHUTTLE), assignCommand, shuttleThread);
             if (commands == null) {
                 News.taskInfo(wrkMast.getWrkNo(), "{}浠诲姟锛寋}灏忚溅锛岃矾寰勮绠楀け璐�", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
-
-                //鎵�浣跨敤鐨勮矾寰勮繘琛岄攣瀹氱鐢�
-                navigateMapUtils.writeNavigateNodeToRedisMap(Utils.getLev(wrkMast.getLocNo()), shuttleProtocol.getShuttleNo(), targetNodes, false);
                 return false;//璺緞瑙ｉ攣澶辫触
             }
 
             assignCommand.setCommands(commands);
 
-            wrkMast.setWrkSts(WrkStsType.MOVE_SITE.sts);//灏忚溅绉诲姩鍒版彁鍗囨満涓�  301.鐢熸垚灏忚溅绉诲簱浠诲姟 ==> 302.灏忚溅绉诲姩鑷崇珯鐐�
+            wrkMast.setWrkSts(WrkStsType.MOVE_NEARBY.sts);//灏忚溅绉诲姩鍒版彁鍗囨満涓�  301.鐢熸垚灏忚溅绉诲簱浠诲姟 ==> 302.灏忚溅绉诲姩鑷宠繎鐐逛腑
+            wrkMast.setSourceStaNo(recentLiftStation.getSiteId());
+            wrkMast.setStaNo(targetLiftSta.getSiteId());
             wrkMast.setModiTime(now);
-            wrkMast.setLiftNo(liftSta.getLiftNo());//鎻愬墠閿佸畾鎻愬崌鏈�
             wrkMast.setSystemMsg("");//娓呯┖娑堟伅
-//            shuttleProtocol.setToken(wrkMast.getWrkNo());//鐙崰璇ュ皬杞︿护鐗�
+            if (wrkMastService.updateById(wrkMast)) {
+                //涓嬪彂浠诲姟
+                shuttleAction.assignWork(shuttleProtocol.getShuttleNo(), assignCommand);
+                notifyUtils.notify(String.valueOf(SlaveType.Shuttle), shuttleProtocol.getShuttleNo(), String.valueOf(wrkMast.getWrkNo()), wrkMast.getWmsWrkNo(), NotifyMsgType.SHUTTLE_MOVING);
+                //瑙﹀彂閫氱煡
+                return false;
+            }
+            return false;
+        }
+        return true;
+    }
+
+    /**
+     * 灏忚溅杩佺Щ-灏忚溅杩佸叆鎻愬崌鏈轰腑
+     * 濡傞渶涓绘柟娉曟墽琛宑ontinue锛岃杩斿洖false
+     * ps:杩斿洖鍊紅rue骞朵笉浠ｈ〃璇ユ柟娉曟墽琛屾垚鍔燂紝杩斿洖鍊间粎鍋氭爣璁扮敤浜庝富鏂规硶鏄惁鎵цcontinue
+     */
+    private boolean shuttleMoveExecuteStepMoveInLift(WrkMast wrkMast) {
+        //--------------------------------------灏忚溅杩佸叆鎻愬崌鏈轰腑-----------------------------------------//
+        Date now = new Date();
+
+        //灏忚溅杩佸叆鎻愬崌鏈�  303.灏忚溅绉诲姩鑷宠繎鐐瑰畬鎴� ==> 304.灏忚溅杩佸叆鎻愬崌鏈轰腑
+        if (wrkMast.getWrkSts() == WrkStsType.MOVE_NEARBY_COMPLETE.sts) {
+            //鑾峰彇鍥涘悜绌挎杞︾嚎绋�
+            ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, wrkMast.getShuttleNo());
+            if (shuttleThread == null) {
+                return false;
+            }
+            ShuttleProtocol shuttleProtocol = shuttleThread.getStatus();
+            if (shuttleProtocol == null) {
+                return false;
+            }
+
+            //灏忚溅澶勪簬绌洪棽鐘舵��
+            if (!shuttleThread.isIdle()) {
+                News.taskInfo(wrkMast.getWrkNo(), "{}浠诲姟锛寋}灏忚溅锛屽皬杞﹀繖纰屼腑", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
+                return false;
+            }
+
+            //鑾峰彇婧愯緭閫佺珯
+            LiftStaProtocol liftSta = LiftUtils.getLiftStaByStaNo(wrkMast.getSourceStaNo());
+            if (liftSta == null) {
+                return false;//鎵句笉鍒扮珯鐐�
+            }
+
+            if (liftSta.getHasCar()) {
+                News.taskInfo(wrkMast.getWrkNo(), "{}浠诲姟锛屾簮绔欏瓨鍦ㄥ皬杞�", wrkMast.getWrkNo());
+                return false;
+            }
+
+            //鑾峰彇鐩爣杈撻�佺珯
+            LiftStaProtocol liftStaTarget = LiftUtils.getLiftStaByStaNo(wrkMast.getStaNo());
+            if (liftStaTarget == null) {
+                return false;//鎵句笉鍒扮珯鐐�
+            }
+
+            if (liftStaTarget.getHasCar()) {
+                News.taskInfo(wrkMast.getWrkNo(), "{}浠诲姟锛岀洰鏍囩珯瀛樺湪灏忚溅", wrkMast.getWrkNo());
+                return false;
+            }
+
+            if (wrkMast.getLiftNo() == null) {
+                //鐢宠鎻愬崌鏈鸿祫婧�
+                boolean applyLift = liftAction.applyLift(liftSta.getLiftNo(), wrkMast.getWrkNo());
+                if(!applyLift) {
+                    News.taskInfo(wrkMast.getWrkNo(), "{}浠诲姟锛岀敵璇锋彁鍗囨満璧勬簮澶辫触锛岀姝㈢Щ鍔�", wrkMast.getWrkNo());
+                    return false;
+                }
+                return false;
+            }
+
+            LiftThread liftThread = (LiftThread) SlaveConnection.get(SlaveType.Lift, wrkMast.getLiftNo());
+            if (liftThread == null) {
+                return false;
+            }
+
+            LiftProtocol liftProtocol = liftThread.getStatus();
+            if (liftProtocol == null) {
+                return false;
+            }
+
+            if (!liftThread.isIdle()) {
+                News.taskInfo(wrkMast.getWrkNo(), "{}浠诲姟锛寋}鍙锋彁鍗囨満锛屾彁鍗囨満蹇欑涓紝绂佹娲惧彂", wrkMast.getWrkNo(), wrkMast.getLiftNo());
+                return false;
+            }
+
+            Object object = redisUtil.get(RedisKeyType.LIFT_MOVE_TO_SHUTTLE_LIMIT.key + wrkMast.getWrkNo());
+            int targetLev = Utils.getLev(shuttleProtocol.getCurrentLocNo());
+            if (object == null || liftProtocol.getLev() != targetLev) {
+                //鑾峰彇鎻愬崌鏈哄懡浠�
+                LiftStaProtocol startSta = LiftUtils.getLiftStaByLev(liftProtocol.getLiftNo(), liftProtocol.getLev());
+                LiftStaProtocol targetSta = LiftUtils.getLiftStaByLev(liftProtocol.getLiftNo(), targetLev);
+                if (startSta == null || targetSta == null) {
+                    News.taskInfo(wrkMast.getWrkNo(), "{}浠诲姟锛寋}鍙锋彁鍗囨満锛岀珯鐐规暟鎹笉瀛樺湪", wrkMast.getWrkNo(), wrkMast.getLiftNo());
+                    return false;
+                }
+                LiftCommand liftCommand = liftThread.getMoveCommand(commonService.getWorkNo(WrkIoType.PREVIEW_LIFT_MOVE.id), startSta.getSiteId(), targetSta.getSiteId());
+                ArrayList<LiftCommand> commands = new ArrayList<>();
+                commands.add(liftCommand);
+
+                //鎻愪氦鍒扮嚎绋嬪幓宸ヤ綔
+                LiftAssignCommand assignCommand = new LiftAssignCommand();
+                assignCommand.setCommands(commands);
+                assignCommand.setLiftNo(wrkMast.getLiftNo());
+                assignCommand.setTaskNo(wrkMast.getWrkNo());
+                assignCommand.setTaskMode(LiftTaskModeType.MOVE.id);
+                //涓嬪彂浠诲姟
+                liftAction.assignWork(wrkMast.getLiftNo(), assignCommand);
+                News.taskInfo(wrkMast.getWrkNo(), "{}浠诲姟锛寋}鍙锋彁鍗囨満鍦▄}灞傦紝鎻愬崌鏈轰笉鍦ㄥ皬杞﹀眰锛岃皟搴︾Щ鍔ㄤ腑", wrkMast.getWrkNo(), liftProtocol.getLev(), wrkMast.getLiftNo());
+                redisUtil.set(RedisKeyType.LIFT_MOVE_TO_SHUTTLE_LIMIT.key + wrkMast.getWrkNo(), "lift_moving", 60 * 3);
+                redisUtil.set(RedisKeyType.TASK_RUN_LIMIT.key + wrkMast.getWrkNo(), "lock", 8);
+                return false;
+            }
+
+            Object limitObj = redisUtil.get(RedisKeyType.TASK_RUN_LIMIT.key + wrkMast.getWrkNo());
+            if (limitObj != null) {
+                return false;
+            }
+
+            String liftLocNo = liftThread.getCurrentLocNo();
+
+            ShuttleAssignCommand assignCommand = new ShuttleAssignCommand();
+            assignCommand.setShuttleNo(shuttleProtocol.getShuttleNo()); // 鍥涘悜绌挎杞︾紪鍙�
+            assignCommand.setTaskMode(ShuttleTaskModeType.MOVE_LOC_NO.id);//灏忚溅绉诲簱浠诲姟
+            assignCommand.setTaskNo(wrkMast.getWrkNo());//浠诲姟鍙�
+            assignCommand.setSourceLocNo(shuttleProtocol.getCurrentLocNo());//婧愬簱浣�
+            assignCommand.setLocNo(liftLocNo);
+            assignCommand.setAuto(true);//鑷姩妯″紡
+
+            //鑾峰彇灏忚溅鍒版彁鍗囨満琛岃蛋鍛戒护
+            List<ShuttleCommand> commands = shuttleOperaUtils.getStartToTargetCommands(shuttleProtocol.getCurrentLocNo(), liftLocNo, NavigationMapType.getMapTypes(NavigationMapType.NORMAL), assignCommand, shuttleThread, "inLift");
+            if (commands == null) {
+                News.taskInfo(wrkMast.getWrkNo(), "{}浠诲姟锛寋}灏忚溅锛岃矾寰勮绠楀け璐�", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
+                return false;//璺緞瑙ｉ攣澶辫触
+            }
+
+            assignCommand.setCommands(commands);
+
+            wrkMast.setWrkSts(WrkStsType.MOVE_IN_LIFT.sts);//303.灏忚溅绉诲姩鑷宠繎鐐瑰畬鎴� ==> 304.灏忚溅杩佸叆鎻愬崌鏈轰腑
+            wrkMast.setModiTime(now);
+            wrkMast.setSystemMsg("");//娓呯┖娑堟伅
             if (wrkMastService.updateById(wrkMast)) {
                 //涓嬪彂浠诲姟
                 shuttleAction.assignWork(shuttleProtocol.getShuttleNo(), assignCommand);
@@ -1528,33 +1744,25 @@
         //--------------------------------------鎻愬崌鏈烘惉杩愪腑-----------------------------------------//
         Date now = new Date();
 
-        //鎻愬崌鏈烘惉杩愪腑  303.灏忚溅绉诲姩鑷崇珯鐐瑰畬鎴� ==> 306.鎻愬崌鏈烘惉杩愪腑
-        if (wrkMast.getWrkSts() == WrkStsType.MOVE_SITE_COMPLETE.sts) {
-            ForkLiftThread forkLiftThread = (ForkLiftThread) SlaveConnection.get(SlaveType.ForkLift, wrkMast.getLiftNo());
-            if (forkLiftThread == null) {
+        //鎻愬崌鏈烘惉杩愪腑  305.灏忚溅杩佸叆鎻愬崌鏈哄畬鎴� ==> 306.鎻愬崌鏈烘惉杩愪腑
+        if (wrkMast.getWrkSts() == WrkStsType.MOVE_IN_LIFT_COMPLETE.sts) {
+            LiftThread liftThread = (LiftThread) SlaveConnection.get(SlaveType.Lift, wrkMast.getLiftNo());
+            if (liftThread == null) {
                 return false;
             }
-            ForkLiftProtocol forkLiftProtocol = forkLiftThread.getStatus();
-            if (forkLiftProtocol == null) {
+            LiftProtocol liftProtocol = liftThread.getStatus();
+            if (liftProtocol == null) {
                 return false;
             }
-            if (!forkLiftThread.isIdle()) {
+            if (!liftThread.isIdle()) {
                 News.taskInfo(wrkMast.getWrkNo(), "{}浠诲姟锛寋}鍙锋彁鍗囨満锛屾彁鍗囨満蹇欑涓紝绂佹娲惧彂", wrkMast.getWrkNo(), wrkMast.getLiftNo());
                 return false;
             }
-            //鍒ゆ柇鎻愬崌鏈烘槸鍚︽湁鍏朵粬浠诲姟
-            WrkMast liftWrkMast = wrkMastService.selectLiftWrkMast(wrkMast.getLiftNo());
-            if (liftWrkMast != null) {
-                if (!liftWrkMast.getWrkNo().equals(wrkMast.getWrkNo())) {//鎻愬崌鏈轰换鍔″拰褰撳墠浠诲姟涓嶇浉鍚�
-                    News.taskInfo(wrkMast.getWrkNo(), "{}浠诲姟锛寋}鍙锋彁鍗囨満锛屾彁鍗囨満瀛樺湪鏈畬鎴愪换鍔★紝绂佹娲惧彂", wrkMast.getWrkNo(), wrkMast.getLiftNo());
-                    return false;//褰撳墠鎻愬崌鏈哄瓨鍦ㄦ湭瀹屾垚浠诲姟锛岀瓑寰呬笅涓�娆¤疆璇�
-                }
-            }
 
             //鑾峰彇婧愮珯
-            ForkLiftStaProtocol sourceLiftSta = ForkLiftUtils.getLiftStaByStaNo(wrkMast.getSourceStaNo());
+            LiftStaProtocol sourceLiftSta = LiftUtils.getLiftStaByStaNo(wrkMast.getSourceStaNo());
             //鑾峰彇鐩爣绔�
-            ForkLiftStaProtocol liftSta = ForkLiftUtils.getLiftStaByStaNo(wrkMast.getStaNo());
+            LiftStaProtocol liftSta = LiftUtils.getLiftStaByStaNo(wrkMast.getStaNo());
             if (sourceLiftSta == null || liftSta == null) {
                 News.taskInfo(wrkMast.getWrkNo(), "{}浠诲姟锛岀己灏戠珯鐐逛俊鎭紝绂佹娲惧彂", wrkMast.getWrkNo());
                 return false;//缂哄皯绔欑偣淇℃伅
@@ -1566,23 +1774,23 @@
             }
 
             //鑾峰彇鎻愬崌鏈哄懡浠�
-            List<ForkLiftCommand> liftCommands = forkLiftThread.getShuttleSwitchCommand(wrkMast.getWrkNo(), sourceLiftSta.getLev(), liftSta.getLev());
-            ArrayList<ForkLiftCommand> commands = new ArrayList<>();
-            commands.addAll(liftCommands);
+            LiftCommand liftCommand = liftThread.getShuttleSwitchCommand(wrkMast.getWrkNo(), sourceLiftSta.getSiteId(), liftSta.getSiteId());
+            ArrayList<LiftCommand> commands = new ArrayList<>();
+            commands.add(liftCommand);
 
             //鎻愪氦鍒扮嚎绋嬪幓宸ヤ綔
             LiftAssignCommand assignCommand = new LiftAssignCommand();
             assignCommand.setCommands(commands);
-            assignCommand.setLiftNo(wrkMast.getLiftNo().shortValue());
-            assignCommand.setTaskNo(wrkMast.getWrkNo().shortValue());
-            assignCommand.setTaskMode(ForkLiftTaskModeType.SHUTTLE_SWITCH.id.shortValue());
+            assignCommand.setLiftNo(wrkMast.getLiftNo());
+            assignCommand.setTaskNo(wrkMast.getWrkNo());
+            assignCommand.setTaskMode(LiftTaskModeType.SHUTTLE_SWITCH.id);
 
-            wrkMast.setWrkSts(WrkStsType.MOVE_LIFT_RUN.sts);//鎻愬崌鏈烘惉杩愪腑  303.灏忚溅绉诲姩鑷崇珯鐐瑰畬鎴� ==> 306.鎻愬崌鏈烘惉杩愪腑
+            wrkMast.setWrkSts(WrkStsType.MOVE_LIFT_RUN.sts);//鎻愬崌鏈烘惉杩愪腑  305.灏忚溅杩佸叆鎻愬崌鏈哄畬鎴� ==> 306.鎻愬崌鏈烘惉杩愪腑
             wrkMast.setSystemMsg("");//娓呯┖娑堟伅
             wrkMast.setModiTime(now);
             if (wrkMastService.updateById(wrkMast)) {
                 //涓嬪彂浠诲姟
-                forkLiftAction.assignWork(wrkMast.getLiftNo(), assignCommand);
+                liftAction.assignWork(wrkMast.getLiftNo(), assignCommand);
             }
         }
         return true;
@@ -1615,25 +1823,64 @@
                 return false;
             }
 
+            if (Utils.getLev(shuttleProtocol.getCurrentLocNo()) != Utils.getLev(wrkMast.getLocNo())) {
+                Object object = redisUtil.get(RedisKeyType.SHUTTLE_UPDATE_LOCATION.key + shuttleProtocol.getShuttleNo());
+                if(object != null) {
+                    return false;
+                }
+
+                ShuttleAssignCommand assignCommand = new ShuttleAssignCommand();
+                assignCommand.setShuttleNo(shuttleProtocol.getShuttleNo()); // 鍥涘悜绌挎杞︾紪鍙�
+                assignCommand.setTaskMode(ShuttleTaskModeType.UPDATE_LOCATION.id);//鏇存柊鍧愭爣
+                assignCommand.setTaskNo(wrkMast.getWrkNo());//浠诲姟鍙�
+                assignCommand.setAuto(true);//鑷姩妯″紡
+                assignCommand.setSourceLocNo(shuttleProtocol.getCurrentLocNo());//婧愬簱浣�
+                assignCommand.setLocNo(wrkMast.getLocNo());//鐩爣搴撲綅
+
+                //鏇存柊灏忚溅鍧愭爣
+                ShuttleCommand command = shuttleThread.getUpdateLocationCommand(wrkMast.getWrkNo(), wrkMast.getLocNo());
+                ArrayList<ShuttleCommand> commands = new ArrayList<>();
+                commands.add(command);
+
+                assignCommand.setCommands(commands);
+                //涓嬪彂浠诲姟
+                shuttleAction.assignWork(shuttleProtocol.getShuttleNo(), assignCommand);
+                redisUtil.set(RedisKeyType.SHUTTLE_UPDATE_LOCATION.key + shuttleProtocol.getShuttleNo(), "update", 10);
+                return false;
+            }
+
+            //灏忚溅鍑烘彁鍗囨満杩戠偣璺濈
+            int shuttleOutLiftLocationDistance = 2;
+            Config shuttleOutLiftLocationDistanceConfig = configService.selectOne(new EntityWrapper<Config>().eq("code", "shuttleOutLiftLocationDistance"));
+            if (shuttleOutLiftLocationDistanceConfig != null) {
+                shuttleOutLiftLocationDistance = Integer.parseInt(shuttleOutLiftLocationDistanceConfig.getValue());
+            }
+
+            String targetLocNo = navigateUtils.calcFirstLocation(shuttleProtocol.getCurrentLocNo(), wrkMast.getLocNo(), NavigationMapType.getMapTypes(NavigationMapType.NORMAL), null, null, shuttleOutLiftLocationDistance);
+            if (targetLocNo == null) {//鍑烘彁鍗囨満杩戠偣璁＄畻澶辫触
+                News.taskInfo(wrkMast.getWrkNo(), "{}浠诲姟锛寋}灏忚溅锛屽嚭鎻愬崌鏈鸿繎鐐硅绠楀け璐�", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
+                return false;
+            }
+
             ShuttleAssignCommand assignCommand = new ShuttleAssignCommand();
             assignCommand.setShuttleNo(shuttleProtocol.getShuttleNo()); // 鍥涘悜绌挎杞︾紪鍙�
-            assignCommand.setTaskMode(ShuttleTaskModeType.UPDATE_LOCATION.id);//鏇存柊鍧愭爣
+            assignCommand.setTaskMode(ShuttleTaskModeType.MOVE_LOC_NO.id);//灏忚溅绉诲簱浠诲姟
             assignCommand.setTaskNo(wrkMast.getWrkNo());//浠诲姟鍙�
             assignCommand.setAuto(true);//鑷姩妯″紡
             assignCommand.setSourceLocNo(shuttleProtocol.getCurrentLocNo());//婧愬簱浣�
-            assignCommand.setLocNo(wrkMast.getLocNo());//鐩爣搴撲綅
+            assignCommand.setLocNo(targetLocNo);//鐩爣搴撲綅
 
-            //鏇存柊灏忚溅鍧愭爣
-            ShuttleCommand command = shuttleThread.getUpdateLocationCommand(wrkMast.getWrkNo(), wrkMast.getLocNo());
-            ArrayList<ShuttleCommand> commands = new ArrayList<>();
-            commands.add(command);
-
+            //鑾峰彇灏忚溅鍒拌繎鐐瑰懡浠�
+            List<ShuttleCommand> commands = shuttleOperaUtils.getStartToTargetCommands(shuttleProtocol.getCurrentLocNo(), targetLocNo, NavigationMapType.getMapTypes(NavigationMapType.NORMAL), assignCommand, shuttleThread);
+            if (commands == null) {
+                News.taskInfo(wrkMast.getWrkNo(), "{}浠诲姟锛寋}灏忚溅锛岃矾寰勮绠楀け璐�", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
+                return false;//璺緞璁＄畻澶辫触
+            }
             assignCommand.setCommands(commands);
 
             wrkMast.setWrkSts(WrkStsType.MOVE_OUT_LIFT.sts);//灏忚溅杩佸嚭鎻愬崌鏈轰腑
             wrkMast.setSystemMsg("");//娓呯┖娑堟伅
             wrkMast.setModiTime(now);
-
             if (wrkMastService.updateById(wrkMast)) {
                 //涓嬪彂浠诲姟
                 shuttleAction.assignWork(shuttleProtocol.getShuttleNo(), assignCommand);
@@ -1687,26 +1934,8 @@
             assignCommand.setSourceLocNo(shuttleProtocol.getCurrentLocNo());//婧愬簱浣�
             assignCommand.setLocNo(wrkMast.getLocNo());//鐩爣搴撲綅
 
-            List<ShuttleCommand> commands = null;
-            //璺ㄦゼ灞傜Щ鍔ㄤ换鍔�
-            if (Utils.getLev(wrkMast.getSourceLocNo()) != Utils.getLev(wrkMast.getLocNo())) {
-                //闇�瑕佸皢鍓嶄袱涓妭鐐逛綔涓虹櫧鍚嶅崟鑺傜偣浼犲叆
-                List<NavigateNode> targetNodes = ForkLiftUtils.getLiftStaNodes(wrkMast.getStaNo());
-                if (targetNodes == null) {
-                    return false;//鏈幏鍙栧埌鑺傜偣
-                }
-
-                //璁剧疆璁＄畻鑺傜偣鐨勭櫧鍚嶅崟
-                ArrayList<int[]> whiteList = new ArrayList<>();//璁剧疆璁＄畻鑺傜偣鐨勭櫧鍚嶅崟
-                for (NavigateNode node : targetNodes) {
-                    whiteList.add(new int[]{node.getX(), node.getY()});
-                }
-                commands = shuttleOperaUtils.getStartToTargetCommands(shuttleProtocol.getCurrentLocNo(), wrkMast.getLocNo(), NavigationMapType.NORMAL.id, whiteList, assignCommand, shuttleThread);
-            }else {
-                //鑾峰彇灏忚溅鍒扮洰鏍囧簱浣嶅懡浠�
-                commands = shuttleOperaUtils.getStartToTargetCommands(shuttleProtocol.getCurrentLocNo(), wrkMast.getLocNo(), NavigationMapType.NORMAL.id, assignCommand, shuttleThread);
-            }
-
+            //鑾峰彇灏忚溅鍒扮洰鏍囧簱浣嶅懡浠�
+            List<ShuttleCommand> commands = shuttleOperaUtils.getStartToTargetCommands(shuttleProtocol.getCurrentLocNo(), wrkMast.getLocNo(), NavigationMapType.getMapTypes(NavigationMapType.NORMAL), assignCommand, shuttleThread);
             if (commands == null) {
                 News.taskInfo(wrkMast.getWrkNo(), "{}浠诲姟锛寋}灏忚溅锛岃矾寰勮绠楀け璐�", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                 return false;//璺緞璁＄畻澶辫触
@@ -1718,72 +1947,12 @@
             wrkMast.setLiftNo(null);//閲婃斁鎻愬崌鏈�
             wrkMast.setSystemMsg("");//娓呯┖娑堟伅
             wrkMast.setModiTime(now);
-
             if (wrkMastService.updateById(wrkMast)) {
                 //涓嬪彂浠诲姟
                 shuttleAction.assignWork(shuttleProtocol.getShuttleNo(), assignCommand);
             }
         }
         return true;
-    }
-
-    //鑷姩鍒囨崲鍑哄叆搴撴ā寮�
-    public void autoSwitchForkLiftIOMode() {
-        for (ForkLiftSlave forkLiftSlave : slaveProperties.getForkLift()) {
-            Integer liftNo = forkLiftSlave.getId();
-            ForkLiftThread forkLiftThread = (ForkLiftThread) SlaveConnection.get(SlaveType.ForkLift, liftNo);
-            if (forkLiftThread == null) {
-                continue;
-            }
-            ForkLiftProtocol forkLiftProtocol = forkLiftThread.getStatus();
-            if (forkLiftProtocol == null) {
-                continue;
-            }
-
-            //鑾峰彇鍏ュ簱浠诲姟
-            List<WrkMast> inWrkMasts = wrkMastService.selectList(new EntityWrapper<WrkMast>()
-                    .eq("lift_no", liftNo)
-                    .in("wrk_sts"
-                            , WrkStsType.NEW_INBOUND.sts
-                            , WrkStsType.INBOUND_DEVICE_RUN.sts
-                            , WrkStsType.INBOUND_LIFT_RUN.sts
-                            , WrkStsType.INBOUND_LIFT_RUN_COMPLETE.sts
-                            , WrkStsType.INBOUND_SHUTTLE_RUN.sts
-                            , WrkStsType.INBOUND_SHUTTLE_RUN_COMPLETE.sts
-                    ));
-
-            //鑾峰彇鍑哄簱浠诲姟
-            List<WrkMast> outWrkMasts = wrkMastService.selectList(new EntityWrapper<WrkMast>()
-                    .eq("lift_no", liftNo)
-                    .in("wrk_sts"
-                            , WrkStsType.NEW_OUTBOUND.sts
-                            , WrkStsType.OUTBOUND_SHUTTLE_RUN.sts
-                            , WrkStsType.OUTBOUND_SHUTTLE_RUN_COMPLETE.sts
-                            , WrkStsType.OUTBOUND_LIFT_RUN.sts
-                            , WrkStsType.OUTBOUND_LIFT_RUN_COMPLETE.sts
-                    ));
-
-            if (forkLiftProtocol.getIOModeType().equals(ForkLiftIoModeType.NONE)) {
-                //鏈煡妯″紡
-                if (!inWrkMasts.isEmpty()) {
-                    forkLiftThread.switchIOMode(ForkLiftIoModeType.IN);
-                } else if (!outWrkMasts.isEmpty()) {
-                    forkLiftThread.switchIOMode(ForkLiftIoModeType.OUT);
-                }else {
-                    forkLiftThread.switchIOMode(ForkLiftIoModeType.IN);
-                }
-            } else if (forkLiftProtocol.getIOModeType().equals(ForkLiftIoModeType.IN)) {
-                //鍏ュ簱妯″紡
-                if (inWrkMasts.isEmpty() && !outWrkMasts.isEmpty()) {
-                    forkLiftThread.switchIOMode(ForkLiftIoModeType.OUT);
-                }
-            } else if (forkLiftProtocol.getIOModeType().equals(ForkLiftIoModeType.OUT)) {
-                //鍑哄簱妯″紡
-                if (outWrkMasts.isEmpty() && !inWrkMasts.isEmpty()) {
-                    forkLiftThread.switchIOMode(ForkLiftIoModeType.IN);
-                }
-            }
-        }
     }
 
 }

--
Gitblit v1.9.1