From 0dc1710c16ee9258018ca79a389efc6b2cc71375 Mon Sep 17 00:00:00 2001
From: tqs <56479841@qq.com>
Date: 星期五, 02 十二月 2022 18:12:42 +0800
Subject: [PATCH] #

---
 src/main/java/com/zy/core/enums/RgvStatusType.java          |    3 
 src/main/java/com/zy/core/thread/RgvThread.java             |   22 
 src/main/java/com/zy/core/thread/SiemensCrnThread.java      |    2 
 src/main/java/com/zy/core/model/RgvSlave.java               |   11 
 src/main/java/com/zy/asrs/service/impl/MainServiceImpl.java |  858 ++++++++++++++++++++++++++++++++++++--------------
 src/main/java/com/zy/asrs/mapper/WrkMastMapper.java         |   45 ++
 src/main/resources/mapper/WrkMastMapper.xml                 |   31 +
 src/main/java/com/zy/core/MainProcess.java                  |   14 
 src/main/resources/application.yml                          |   18 
 9 files changed, 745 insertions(+), 259 deletions(-)

diff --git a/src/main/java/com/zy/asrs/mapper/WrkMastMapper.java b/src/main/java/com/zy/asrs/mapper/WrkMastMapper.java
index c1d08a1..ac14bfa 100644
--- a/src/main/java/com/zy/asrs/mapper/WrkMastMapper.java
+++ b/src/main/java/com/zy/asrs/mapper/WrkMastMapper.java
@@ -110,10 +110,53 @@
     Integer selectExistInEmpty();
 
     /**
-     * 鏌ユ壘宸ヤ綔鐘舵�佷负2锛堣澶囦笂璧帮級,涓旇揣鐗╁湪RGV鍏ュ簱鎺ラ┏绔欑殑鍏ュ簱宸ヤ綔妗�,鏌ユ壘鏈�澶�2绗�
+     * 鏌ユ壘宸ヤ綔鐘舵�佷负2锛堣澶囦笂璧帮級,涓擱GV鍏ュ簱鎺ラ┏绔欑鍚堢殑鐨勫叆搴撳伐浣滄。
      * @param rgvNo
      * @param staNos
      * @return
      */
     List<WrkMast> selectRgvInStep1(@Param("rgvNo")Integer rgvNo, @Param("staNos")List<Integer> staNos);
+
+    /**
+     * 鏌ユ壘鏄惁瀛樺湪RGV姝e湪宸ヤ綔涓殑浠诲姟
+     * @param rgvNo
+     * @return
+     */
+    List<WrkMast> selectRgvInWorking(@Param("rgvNo")Integer rgvNo);
+
+    /**
+     * 鎸囧畾RGV鍑哄簱绔�,鏌ユ壘宸ヤ綔鐘舵�佷负7(RGV鍏ュ簱鏀捐揣涓�)鐨勫叆搴撳伐浣滄。List
+     * @param rgvInDStn
+     * @return
+     */
+    List<WrkMast> selectRgvInStep2(@Param("rgvInDStn")Integer rgvInDStn);
+
+    /**
+     * 鎸囧畾RGV鍑哄簱绔�,鏌ユ壘宸ヤ綔鐘舵�佷负17(RGV鍑哄簱鏀捐揣涓�)鐨勫嚭搴撳伐浣滄。List
+     * @param rgvOutDStn
+     * @return
+     */
+    List<WrkMast> selectRgvOutStep2(@Param("rgvOutDStn")Integer rgvOutDStn);
+
+    /**
+     * 鎸囧畾RGV鍑哄簱绔�,鏌ユ壘宸ヤ綔鐘舵�佷负7(RGV鍏ュ簱鏀捐揣涓�)鎴� 17(RGV鍑哄簱鏀捐揣涓�) 鐨勫伐浣滄。List
+     * @param rgvDestStn
+     * @return
+     */
+    List<WrkMast> selectRgvDestStep2(@Param("rgvDestStn")Integer rgvDestStn);
+
+    /**
+     * 鏌ユ壘宸ヤ綔鐘舵�佷负14锛堝嚭搴撳畬鎴愶級,涓擱GV鍑哄簱鎺ラ┏绔欑鍚堢殑鐨勫叆搴撳伐浣滄。
+     * @param rgvNo
+     * @param staNos
+     * @return
+     */
+    List<WrkMast> selectRgvOutStep1(@Param("rgvNo")Integer rgvNo, @Param("staNos")List<Integer> staNos);
+
+    /**
+     * 鏌ユ壘鏄惁瀛樺湪RGV姝e湪鍑哄簱宸ヤ綔涓殑浠诲姟
+     * @param rgvNo
+     * @return
+     */
+    List<WrkMast> selectRgvOutWorking(@Param("rgvNo")Integer rgvNo);
 }
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 701cd6c..5fd4ef8 100644
--- a/src/main/java/com/zy/asrs/service/impl/MainServiceImpl.java
+++ b/src/main/java/com/zy/asrs/service/impl/MainServiceImpl.java
@@ -29,6 +29,7 @@
 import com.zy.core.model.*;
 import com.zy.core.model.command.CrnCommand;
 import com.zy.core.model.command.LedCommand;
+import com.zy.core.model.command.RgvCommand;
 import com.zy.core.model.protocol.CrnProtocol;
 import com.zy.core.model.protocol.RgvProtocol;
 import com.zy.core.model.protocol.StaProtocol;
@@ -40,7 +41,6 @@
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.beans.factory.annotation.Value;
-import org.springframework.scheduling.annotation.Async;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 import org.springframework.transaction.interceptor.TransactionAspectSupport;
@@ -104,8 +104,6 @@
                     continue;
                 }
                 String barcode = barcodeThread.getBarcode();
-
-                barcode = "80011105";
 
                 if (!Cools.isEmpty(barcode)) {
                     log.info("{}鍙锋潯鐮佹壂鎻忓櫒妫�娴嬫潯鐮佷俊鎭細{}", inSta.getBarcode(), barcode);
@@ -196,64 +194,6 @@
                         } else {
                             log.error("璇锋眰鎺ュ彛澶辫触锛侊紒锛乽rl锛歿}锛況equest锛歿}锛況esponse锛歿}", wmsUrl + "/rpc/pakin/loc/v1", JSON.toJSONString(param), response);
                         }
-
-
-//                        // 妫�绱㈠簱浣�
-//                        LocTypeDto locTypeDto = new LocTypeDto(staProtocol);
-//                        List<String> matNos = waitPakins.stream().map(WaitPakin::getMatnr).distinct().collect(Collectors.toList());
-//                        StartupDto startupDto = commonService.getLocNo(1, 1, inSta.getStaNo(), matNos, locTypeDto, 0);
-//                        // 宸ヤ綔鍙�
-//                        int workNo = startupDto.getWorkNo();
-//                        // 鎻掑叆宸ヤ綔鏄庣粏妗�
-//                        wrkDetlService.createWorkDetail(workNo, waitPakins, barcode);
-//
-//                        // 鎻掑叆宸ヤ綔涓绘。
-//                        wrkMast = new WrkMast();
-//                        wrkMast.setWrkNo(workNo);
-//                        wrkMast.setIoTime(new Date());
-//                        wrkMast.setWrkSts(2L); // 宸ヤ綔鐘舵�侊細2.璁惧涓婅蛋
-//                        wrkMast.setIoType(1); // 鍏ュ嚭搴撶姸鎬侊細1.鍏ュ簱
-//                        wrkMast.setIoPri(10D); // 浼樺厛绾э細10
-//                        wrkMast.setCrnNo(startupDto.getCrnNo());
-//                        wrkMast.setSourceStaNo(startupDto.getSourceStaNo());
-//                        wrkMast.setStaNo(startupDto.getStaNo());
-//                        wrkMast.setLocNo(startupDto.getLocNo());
-//                        wrkMast.setBarcode(barcode); // 鎵樼洏鐮�
-//                        wrkMast.setFullPlt("Y"); // 婊℃澘锛歒
-//                        wrkMast.setPicking("N"); // 鎷f枡
-//                        wrkMast.setExitMk("N"); // 閫�鍑�
-//                        wrkMast.setEmptyMk("N"); // 绌烘澘
-//                        wrkMast.setLinkMis("N");
-//                        // 鎿嶄綔浜哄憳鏁版嵁
-//                        wrkMast.setAppeTime(new Date());
-//                        wrkMast.setModiTime(new Date());
-//                        Integer insert = wrkMastMapper.insert(wrkMast);
-//                        if (insert == 0) {
-//                            throw new CoolException("淇濆瓨宸ヤ綔妗eけ璐�");
-//                        }
-//                        // 鏇存柊鐩爣搴撲綅鐘舵��
-//                        LocMast locMast = locMastService.selectById(startupDto.getLocNo());
-//                        locMast.setLocSts("S"); // S.鍏ュ簱棰勭害
-//                        locMast.setModiTime(new Date());
-//                        if (!locMastService.updateById(locMast)){
-//                            throw new CoolException("鏀瑰彉搴撲綅鐘舵�佸け璐�");
-//                        }
-//                        // 灏嗗叆搴撻�氱煡妗d慨鏀逛负宸插惎鍔�
-//                        if (wrkMastMapper.updateWaitPakInStep1(barcode) == 0) {
-//                            throw new CoolException("淇敼鍏ュ簱閫氱煡妗g姸鎬佷负宸插惎鍔ㄥけ璐�");
-//                        }
-//
-//                        // 鍛戒护涓嬪彂鍖� --------------------------------------------------------------------------
-//
-//                        // 鏇存柊绔欑偣淇℃伅 涓� 涓嬪彂plc鍛戒护
-//                        barcodeThread.setBarcode("");
-//                        staProtocol.setWorkNo((short) workNo);
-//                        staProtocol.setStaNo(startupDto.getStaNo().shortValue());
-//                        devpThread.setPakMk(staProtocol.getSiteId(), false);
-//                        boolean result = MessageQueue.offer(SlaveType.Devp, devp.getId(), new Task(2, staProtocol));
-//                        if (!result) {
-//                            throw new CoolException("鏇存柊plc绔欑偣淇℃伅澶辫触");
-//                        }
 
                     } catch (Exception e) {
                         e.printStackTrace();
@@ -452,7 +392,6 @@
     /**
      * 鍫嗗灈鏈虹珯鍑哄簱鍒板嚭搴撶珯
      */
-    @Async
     public synchronized void crnStnToOutStn() {
         for (CrnSlave crnSlave : slaveProperties.getCrn()) {
             // 閬嶅巻鍫嗗灈鏈哄嚭搴撶珯
@@ -590,20 +529,20 @@
                 // 濡傛灉鏈�杩戜竴娆℃槸鍏ュ簱妯″紡
                 if (rgvProtocol.getLastIo().equals("I")) {
                     if (basRgv.getInEnable().equals("Y")) {
-//                        this.rgvInStnToLoc(rgv, rgvProtocol); //  鍏ュ簱
+                        this.rgvInStn(rgv, rgvProtocol); //  鍏ュ簱
                         rgvProtocol.setLastIo("O");
                     } else if (basRgv.getOutEnable().equals("Y")) {
-//                        this.locToCrnStn(rgv, crnProtocol); //  鍑哄簱
+                        this.rgvOutStn(rgv, rgvProtocol); //  鍑哄簱
                         rgvProtocol.setLastIo("I");
                     }
                 }
                 // 濡傛灉鏈�杩戜竴娆℃槸鍑哄簱妯″紡
                 else if (rgvProtocol.getLastIo().equals("O")) {
                     if (basRgv.getOutEnable().equals("Y")) {
-//                        this.locToCrnStn(rgv, crnProtocol); //  鍑哄簱
+                        this.rgvOutStn(rgv, rgvProtocol); //  鍑哄簱
                         rgvProtocol.setLastIo("I");
                     } else if (basRgv.getInEnable().equals("Y")) {
-//                        this.rgvInStnToLoc(rgv, rgvProtocol); //  鍏ュ簱
+                        this.rgvInStn(rgv, rgvProtocol); //  鍏ュ簱
                         rgvProtocol.setLastIo("O");
                     }
                 }
@@ -1055,19 +994,23 @@
 //    }
 
     /**
-     * 鍏ュ簱  ===>>  RGV鍏ュ簱绔欏埌绔�
+     * 鏌ユ壘宸ヤ綔鐘舵�佷负2锛堣澶囦笂璧帮級,涓擱GV鍏ュ簱鎺ラ┏绔欑鍚堢殑鐨勫叆搴撳伐浣滄。锛屾彁鍙栧嚭鏈�澶�2绗�
+     * @param slave
+     * @return
      */
-    public synchronized void rgvInStn(RgvSlave slave, RgvProtocol rgvProtocol) {
-        // 鑾峰彇宸ヤ綔鐘舵�佷负2锛堣澶囦笂璧帮級,涓旇揣鐗╁湪RGV鍏ュ簱鎺ラ┏绔欑殑鍏ュ簱宸ヤ綔妗�,鏌ユ壘鏈�澶�2绗�
+    public synchronized List<WrkMast> getRgvInTask(RgvSlave slave){
+        List<WrkMast> wrkMastTask = new ArrayList<>();
         List<Integer> staNos = new ArrayList<>();
-        for (RgvSlave.RgvStn rgvStn : slave.getRgvInStn()) {
+        for (RgvSlave.RgvStn rgvStn : slave.getRgvInSStn()) {
             staNos.add(rgvStn.getStaNo());
         }
-        List<WrkMast> wrkMasts1 = new ArrayList<>();
+        if(staNos.size() < 1){
+            return null;
+        }
         List<WrkMast> wrkMasts = wrkMastMapper.selectRgvInStep1(slave.getId(), staNos);
         for(WrkMast wrkMast : wrkMasts){
             Integer plcId = 0;
-            for (RgvSlave.RgvStn rgvStn : slave.getRgvInStn()) {
+            for (RgvSlave.RgvStn rgvStn : slave.getRgvInSStn()) {
                 if(rgvStn.getStaNo() == wrkMast.getRgvSstaNo()){
                     plcId = rgvStn.getDevpPlcId();
                     break;
@@ -1075,141 +1018,610 @@
             }
 
             DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, plcId);
-            StaProtocol staProtocol = devpThread.getStation().get(wrkMast.getRgvSstaNo());
-            if (staProtocol == null) {
+            //鍒ゆ柇RGV鍏ュ簱婧愮珯鐐癸紝鑷姩銆佹湁鐗╋紝鏈変换鍔″彿锛屽彲鍑�
+            boolean flag1 = false;
+            StaProtocol staProtocol1 = devpThread.getStation().get(wrkMast.getRgvSstaNo());
+            if (staProtocol1 == null) {
                 continue;
             } else {
-                staProtocol = staProtocol.clone();
+                staProtocol1 = staProtocol1.clone();
+            }
+            // 鏌ヨ绔欑偣璇︾粏淇℃伅
+            BasDevp staDetl1 = basDevpService.selectById(wrkMast.getRgvSstaNo());
+            if (staDetl1 == null) {
+                log.error("RGV鍏ュ簱 ===>> 杈撻�佹満婧愮珯鐐瑰湪鏁版嵁搴撲笉瀛樺湪, 绔欑偣缂栧彿={}", wrkMast.getRgvSstaNo());
+                continue;
+            }
+            if (staProtocol1.isAutoing() && staProtocol1.isLoading() && staProtocol1.getWorkNo().intValue() == wrkMast.getWrkNo()
+                    && staProtocol1.isOutEnable() && staDetl1.getOutEnable() != null && staDetl1.getOutEnable().equals("Y")) {
+                flag1 = true;
+            }
+
+            //鍒ゆ柇RGV鍏ュ簱鐩爣绔欑偣锛岃嚜鍔ㄣ�佹棤鐗╋紝娌℃湁浠诲姟鍙凤紝鍙叆
+            boolean flag2 = false;
+            StaProtocol staProtocol2 = devpThread.getStation().get(wrkMast.getRgvDstaNo());
+            if (staProtocol2 == null) {
+                continue;
+            } else {
+                staProtocol2 = staProtocol2.clone();
+            }
+            // 鏌ヨ绔欑偣璇︾粏淇℃伅
+            BasDevp staDetl2 = basDevpService.selectById(wrkMast.getRgvSstaNo());
+            if (staDetl2 == null) {
+                log.error("RGV鍏ュ簱 ===>> 杈撻�佹満婧愮珯鐐瑰湪鏁版嵁搴撲笉瀛樺湪, 绔欑偣缂栧彿={}", wrkMast.getRgvSstaNo());
+                continue;
+            }
+            if (staProtocol2.isAutoing() && staProtocol2.isLoading() && staProtocol2.getWorkNo().intValue() == wrkMast.getWrkNo()
+                    && staProtocol2.isInEnable() && staDetl2.getCanining() != null && staDetl2.getCanining().equals("Y")) {
+                flag2 = true;
+            }
+
+            if(flag1 && flag2){
+                wrkMastTask.add(wrkMast);
+                if(wrkMastTask.size() >= 2) break;
             }
         }
+        return wrkMastTask;
+    }
 
-//        WrkMast wrkMast = wrkMastMapper.selectPakInStep2(slave.getId(), staProtocol.getWorkNo().intValue(), crnStn.getStaNo());
-//        for (CrnSlave.CrnStn crnStn : slave.getCrnInStn()) {
-//            boolean flag = false;
-//            // 鑾峰彇鍫嗗灈鏈哄叆搴撶珯淇℃伅
-//            DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, crnStn.getDevpPlcId());
-//            StaProtocol staProtocol = devpThread.getStation().get(crnStn.getStaNo());
-//            if (staProtocol == null) {
-//                continue;
-//            } else {
-//                staProtocol = staProtocol.clone();
-//            }
-//            // 鏌ヨ绔欑偣璇︾粏淇℃伅
-//            BasDevp staDetl = basDevpService.selectById(crnStn.getStaNo());
-//            if (staDetl == null) {
-//                log.error("鍏ュ簱 ===>> 鍫嗗灈鏈虹珯鐐瑰湪鏁版嵁搴撲笉瀛樺湪, 绔欑偣缂栧彿={}", crnStn.getStaNo());
-//                continue;
-//            }
-//            if (staProtocol.isAutoing() && staProtocol.isLoading() && staProtocol.getWorkNo() > 0 && staProtocol.isInEnable()
-//                    && staDetl.getCanining() != null && staDetl.getCanining().equals("Y")) {
-//                flag = true;
-//            }
-//            if (!flag) {
-//                continue;
-//            }
-//            // 鑾峰彇宸ヤ綔鐘舵�佷负2锛堣澶囦笂璧帮級鐨勫叆搴撳伐浣滄。
-//            WrkMast wrkMast = wrkMastMapper.selectPakInStep2(slave.getId(), staProtocol.getWorkNo().intValue(), crnStn.getStaNo());
-//            if (null == wrkMast) {
-////                log.error("鏌ヨ鏃犲緟鍏ュ簱鏁版嵁--wrk_sts=2, 宸ヤ綔鍙�={}", staProtocol.getWorkNo());
-//                continue;
-//            }
-//            // 鑾峰彇搴撲綅淇℃伅
-//            LocMast locMast = locMastService.selectById(wrkMast.getLocNo());
-//            if (locMast == null) {
-//                log.error("鏌ヨ搴撳瓨鏃犳暟鎹�--搴撲綅鍙穥}", wrkMast.getLocNo());
-//                continue;
-//            }
-//            if (!locMast.getLocSts().equals("S") && !locMast.getLocSts().equals("Q")) {
-//                log.error("鍏ュ簱鎿嶄綔搴撲綅鐘舵�佷笉绗﹀悎--鐘舵��, 搴撲綅鍙�={}锛屽簱浣嶇姸鎬�={}", wrkMast.getLocNo(), locMast.getLocSts());
-//                continue;
-//            }
-//
-//            // 鍫嗗灈鏈烘帶鍒惰繃婊�
-//            if (!crnProtocol.getStatusType().equals(CrnStatusType.IDLE) || crnProtocol.getTaskNo() != 0) {
-//                continue;
-//            }
-//
-//            // 宸茬粡瀛樺湪鍚婅溅鎵ц浠诲姟鏃讹紝鍒欒繃婊�
-//            if (wrkMastMapper.selectWorking(slave.getId()) != null) {
-//                continue;
-//            }
-//
-//            // 鍙屾繁搴撲綅涓旀祬搴撲綅鏈夎揣锛屽垯闇�鍏堝娴呭簱浣嶈繘琛屽簱浣嶇Щ杞�
-//            if (Utils.isDeepLoc(slaveProperties, wrkMast.getLocNo())) {
-//                String shallowLocNo = Utils.getShallowLoc(slaveProperties, wrkMast.getLocNo());
-//                LocMast shallowLoc = locMastService.selectById(shallowLocNo);
-//                // O.绌哄簱浣嶃�丵.鎷f枡/鐩樼偣/骞舵澘鍐嶅叆搴撱�丼.鍏ュ簱棰勭害銆乆.绂佺敤 鐩存帴鎼紒
-//                if (shallowLoc.getLocSts().equals("P") || shallowLoc.getLocSts().equals("R")) {
-//                    WrkMast waitWrkMast = wrkMastMapper.selectByLocNo(shallowLocNo);
-//                    if (null == waitWrkMast) {
-//                        log.error("{}搴撲綅寮傚父锛屾湭妫�绱㈠埌鐩稿簲宸ヤ綔妗o紒", shallowLocNo);
-//                    } else {
-//                        waitWrkMast.setIoPri(15D);
-//                        waitWrkMast.setModiTime(new Date());
-//                        if (wrkMastMapper.updateById(waitWrkMast) == 0) {
-//                            log.error("璋冩暣宸ヤ綔妗d紭鍏堢骇澶辫触锛佸伐浣滃彿={}", waitWrkMast.getWrkNo());
-//                        }
-//                        continue;
-//                    }
-//
-//                } else if (shallowLoc.getLocSts().equals("F") || shallowLoc.getLocSts().equals("D")) {
-//                    // 姝ゆ爣璁伴伩鍏嶅娆℃墽琛岀Щ搴撲换鍔�
-//                    if (Cools.isEmpty(wrkMast.getUpdMk()) || "N".equals(wrkMast.getUpdMk())) {
-//                        wrkMast.setUpdMk("Y");
-//                        wrkMast.setIoPri(14D);
-//                        wrkMastMapper.updateById(wrkMast);
-//                        // 鐢熸垚宸ヤ綔妗�,灏嗘祬搴撲綅绉昏浆鍒版柊鐨勫簱浣嶄腑
-//                        moveLocForDeepLoc(slave, shallowLoc);
-//                        // 鐢熸垚宸ヤ綔妗c�佹敼鍙樻祬搴撲綅鐨勬簮搴�/鐩爣搴� 搴撲綅鐘舵�併�佷笅鍙戝爢鍨涙満鍛戒护锛堢珛椹墽琛�)
-////                        moveLocForDeepLocPakin(slave, shallowLoc, wrkMast);
-//                    }
-//                    continue;
-//                } else if (shallowLoc.getLocSts().equals("Q")) {
-//                    WrkMast waitWrkMast = wrkMastMapper.selectByLocNo(shallowLocNo);
-//                    if (null != waitWrkMast && waitWrkMast.getWrkSts() == 4) {
-//                        continue;
-//                    }
-//                }
-//            }
-//
-//            // 鍛戒护涓嬪彂鍖� --------------------------------------------------------------------------
-//            CrnCommand crnCommand = new CrnCommand();
-//            crnCommand.setCrnNo(slave.getId()); // 鍫嗗灈鏈虹紪鍙�
-//            crnCommand.setTaskNo(wrkMast.getWrkNo().shortValue()); // 宸ヤ綔鍙�
-//            crnCommand.setAckFinish((short) 0);  // 浠诲姟瀹屾垚纭浣�
-//            crnCommand.setTaskMode(CrnTaskModeType.LOC_MOVE); // 浠诲姟妯″紡:  搴撲綅绉昏浆
-//            crnCommand.setSourcePosX(crnStn.getRow().shortValue());     // 婧愬簱浣嶆帓
-//            crnCommand.setSourcePosY(crnStn.getBay().shortValue());     // 婧愬簱浣嶅垪
-//            crnCommand.setSourcePosZ(crnStn.getLev().shortValue());     // 婧愬簱浣嶅眰
-//            crnCommand.setDestinationPosX(locMast.getRow1().shortValue());     // 鐩爣搴撲綅鎺�
-//            crnCommand.setDestinationPosY(locMast.getBay1().shortValue());     // 鐩爣搴撲綅鍒�
-//            crnCommand.setDestinationPosZ(locMast.getLev1().shortValue());     // 鐩爣搴撲綅灞�
-//            if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getCrnNo(), new Task(2, crnCommand))) {
-//                log.error("鍫嗗灈鏈哄懡浠や笅鍙戝け璐ワ紝鍫嗗灈鏈哄彿={}锛屼换鍔℃暟鎹�={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
-//            } else {
-//
-////                long startTime = System.currentTimeMillis();
-////                while ((System.currentTimeMillis() - startTime) < COMMAND_TIMEOUT) {
-////
-////                    if (true) {
-////                        break;
-////                    }
-////
-////                    try{
-////                        Thread.sleep(500);
-////                    }catch(Exception ignore){}
-////                }
-//
-//                // 淇敼宸ヤ綔妗g姸鎬� 2.璁惧涓婅蛋 => 3.鍚婅溅鍏ュ簱涓�
-//                Date now = new Date();
-//                wrkMast.setWrkSts(3L);
-//                wrkMast.setCrnStrTime(now);
-//                wrkMast.setModiTime(now);
-//                if (wrkMastMapper.updateById(wrkMast) == 0) {
-//                    log.error("淇敼宸ヤ綔妗g姸鎬� 2.璁惧涓婅蛋 => 3.鍚婅溅鍏ュ簱涓� 澶辫触锛侊紒锛屽伐浣滃彿={}", wrkMast.getWrkNo());
-//                }
-//            }
-//        }
+    /**
+     * 鍏ュ簱  ===>>  RGV鍏ュ簱绔欏埌绔�
+     */
+    public synchronized void rgvInStn(RgvSlave slave, RgvProtocol rgvProtocol) {
+        //鏌ユ壘宸ヤ綔鐘舵�佷负2锛堣澶囦笂璧帮級,涓擱GV鍏ュ簱鎺ラ┏绔欑鍚堢殑鐨勫叆搴撳伐浣滄。锛屾彁鍙栧嚭鏈�澶�2绗�
+        List<WrkMast> wrkMastTask = getRgvInTask(slave);
+        if(wrkMastTask.size() <= 0){
+            return;
+        }
+
+        // RGV鎺у埗杩囨护锛� 蹇呴』婊¤冻鑷姩銆佺┖闂诧紝娌℃湁浠诲姟鍙�
+        if (!rgvProtocol.getStatusType().equals(CrnStatusType.IDLE)
+                || rgvProtocol.getModeType() != RgvModeType.AUTO
+                || rgvProtocol.getTaskNo1() != 0 || rgvProtocol.getTaskNo2() != 0) {
+            return;
+        }
+
+        // 宸茬粡瀛樺湪RGV鎵ц浠诲姟鏃讹紝鍒欒繃婊�
+        if(wrkMastMapper.selectRgvInWorking(slave.getId()).size() > 0){
+            return;
+        }
+
+        if(wrkMastTask.size() == 2){
+            //鏈�2绗擱GV寰呭叆搴撲换鍔★紝2涓伐浣嶏紝鍙栬揣銆佹斁璐т换鍔″悓鏃朵笅鍙�
+            WrkMast wrkMast1 = wrkMastTask.get(0);
+            WrkMast wrkMast2 = wrkMastTask.get(1);
+            if(Cools.isEmpty(wrkMast1) || Cools.isEmpty(wrkMast2)){
+                log.error("宸ヤ綔妗GV鍏ュ簱鏁版嵁涓虹┖");
+                return;
+            }
+            //  鍛戒护涓嬪彂鍖� --------------------------------------------------------------------------
+            RgvCommand rgvCommand = new RgvCommand();
+            rgvCommand.setRgvNo(slave.getId()); // RGV缂栧彿
+            rgvCommand.setAckFinish1((short) 0);  // 宸ヤ綅1浠诲姟瀹屾垚纭浣�
+            rgvCommand.setTaskNo1(wrkMast1.getWrkNo().shortValue()); // 宸ヤ綅1宸ヤ綔鍙�
+            rgvCommand.setTaskMode1(RgvTaskModeType.FETCH_PUT); // 宸ヤ綅1浠诲姟妯″紡:  鍙栨斁璐�
+            rgvCommand.setSourceStaNo1(wrkMast1.getRgvSstaNo().shortValue());   //宸ヤ綅1婧愮珯鐐�
+            rgvCommand.setDestinationStaNo1(wrkMast1.getRgvDstaNo().shortValue());   //宸ヤ綅1鐩爣绔欑偣
+            rgvCommand.setAckFinish2((short) 0);  // 宸ヤ綅2浠诲姟瀹屾垚纭浣�
+            rgvCommand.setTaskNo2(wrkMast2.getWrkNo().shortValue()); // 宸ヤ綅2宸ヤ綔鍙�
+            rgvCommand.setTaskMode2(RgvTaskModeType.FETCH_PUT); // 宸ヤ綅2浠诲姟妯″紡:  鍙栨斁璐�
+            rgvCommand.setSourceStaNo2(wrkMast2.getRgvSstaNo().shortValue());   //宸ヤ綅2婧愮珯鐐�
+            rgvCommand.setDestinationStaNo2(wrkMast2.getRgvDstaNo().shortValue());   //宸ヤ綅2鐩爣绔欑偣
+            rgvCommand.setCommand((short) 0);   //宸ヤ綅1銆�2浠诲姟纭
+            if (!MessageQueue.offer(SlaveType.Crn, wrkMast1.getRgvNo(), new Task(2, rgvCommand))) {
+                //step=2,宸ヤ綅1銆�2鍐欎换鍔★紱   step=4锛屽伐浣�1鍐欎换鍔★紱     step=5锛屽伐浣�2鍐欎换鍔�
+                log.error("RGV鍛戒护涓嬪彂澶辫触锛孯GV鍙�={}锛屼换鍔℃暟鎹�={}", slave.getId(), JSON.toJSON(rgvCommand));
+            } else {
+                // 淇敼宸ヤ綔妗g姸鎬� 2.璁惧涓婅蛋 => 6.RGV鍏ュ簱鍙栬揣涓�
+                Date now = new Date();
+                wrkMast1.setWrkSts(6L);
+                wrkMast1.setCrnStrTime(now);
+                wrkMast1.setModiTime(now);
+                if (wrkMastMapper.updateById(wrkMast1) == 0) {
+                    log.error("淇敼宸ヤ綔妗g姸鎬� 2.璁惧涓婅蛋 => 6.RGV鍏ュ簱鍙栬揣涓� 澶辫触锛侊紒锛屽伐浣滃彿={}", wrkMast1.getWrkNo());
+                }
+
+                wrkMast2.setWrkSts(6L);
+                wrkMast2.setCrnStrTime(now);
+                wrkMast2.setModiTime(now);
+                if (wrkMastMapper.updateById(wrkMast2) == 0) {
+                    log.error("淇敼宸ヤ綔妗g姸鎬� 2.璁惧涓婅蛋 => 6.RGV鍏ュ簱鍙栬揣涓� 澶辫触锛侊紒锛屽伐浣滃彿={}", wrkMast2.getWrkNo());
+                }
+            }
+        } else if(wrkMastTask.size() == 1){
+            //鍙湁1绗擱GV寰呭叆搴撲换鍔★紝鍏堜笅鍙戝彇璐т换鍔★紝鍙栬揣鍚庡啀鍒ゆ柇鏄惁鏈変笅涓�绗斿緟鍏ュ簱浠诲姟
+            WrkMast wrkMast1 = wrkMastTask.get(0);
+            if(Cools.isEmpty(wrkMast1)){
+                log.error("宸ヤ綔妗GV鍏ュ簱鏁版嵁涓虹┖");
+                return;
+            }
+            //  鍛戒护涓嬪彂鍖� --------------------------------------------------------------------------
+            RgvCommand rgvCommand = new RgvCommand();
+            rgvCommand.setRgvNo(slave.getId()); // RGV缂栧彿
+            rgvCommand.setAckFinish1((short) 0);  // 宸ヤ綅1浠诲姟瀹屾垚纭浣�
+            rgvCommand.setTaskNo1(wrkMast1.getWrkNo().shortValue()); // 宸ヤ綅1宸ヤ綔鍙�
+            rgvCommand.setTaskMode1(RgvTaskModeType.FETCH); // 宸ヤ綅1浠诲姟妯″紡:  鍙栬揣
+            rgvCommand.setSourceStaNo1(wrkMast1.getRgvSstaNo().shortValue());   //宸ヤ綅1婧愮珯鐐�
+            rgvCommand.setDestinationStaNo1(wrkMast1.getRgvDstaNo().shortValue());   //宸ヤ綅1鐩爣绔欑偣
+            rgvCommand.setCommand((short) 0);   //宸ヤ綅1銆�2浠诲姟纭
+            if (!MessageQueue.offer(SlaveType.Crn, wrkMast1.getRgvNo(), new Task(4, rgvCommand))) {
+                //step=2,宸ヤ綅1銆�2浠诲姟纭锛�   step=4锛屽伐浣�1纭锛�     step=5锛屽伐浣�2浠诲姟纭
+                log.error("RGV鍛戒护涓嬪彂澶辫触锛孯GV鍙�={}锛屼换鍔℃暟鎹�={}", slave.getId(), JSON.toJSON(rgvCommand));
+            } else {
+                // 淇敼宸ヤ綔妗g姸鎬� 2.璁惧涓婅蛋 => 6.RGV鍏ュ簱鍙栬揣涓�
+                Date now = new Date();
+                wrkMast1.setWrkSts(6L);
+                wrkMast1.setCrnStrTime(now);
+                wrkMast1.setModiTime(now);
+                if (wrkMastMapper.updateById(wrkMast1) == 0) {
+                    log.error("淇敼宸ヤ綔妗g姸鎬� 2.璁惧涓婅蛋 => 6.RGV鍏ュ簱鍙栬揣涓� 澶辫触锛侊紒锛屽伐浣滃彿={}", wrkMast1.getWrkNo());
+                }
+            }
+        }
+    }
+
+    /**
+     * 鍑哄簱  ===>>  RGV鍑哄簱绔欏埌绔�
+     */
+    public synchronized void rgvOutStn(RgvSlave slave, RgvProtocol rgvProtocol) {
+        //鏌ユ壘宸ヤ綔鐘舵�佷负14锛堝嚭搴撳畬鎴愶級,涓擱GV鍑哄簱鎺ラ┏绔欑鍚堢殑鐨勫嚭搴撳伐浣滄。锛屾彁鍙栧嚭鏈�澶�2绗�
+        List<WrkMast> wrkMastTask = getRgvOutTask(slave);
+        if(wrkMastTask.size() <= 0){
+            return;
+        }
+
+        // RGV鎺у埗杩囨护锛� 蹇呴』婊¤冻鑷姩銆佺┖闂诧紝娌℃湁浠诲姟鍙�
+        if (!rgvProtocol.getStatusType().equals(CrnStatusType.IDLE)
+                || rgvProtocol.getModeType() != RgvModeType.AUTO
+                || rgvProtocol.getTaskNo1() != 0 || rgvProtocol.getTaskNo2() != 0) {
+            return;
+        }
+
+        // 宸茬粡瀛樺湪RGV鎵ц浠诲姟鏃讹紝鍒欒繃婊�
+        if(wrkMastMapper.selectRgvOutWorking(slave.getId()).size() > 0){
+            return;
+        }
+
+        if(wrkMastTask.size() == 2){
+            //鏈�2绗擱GV寰呭叆搴撲换鍔★紝2涓伐浣嶏紝鍙栬揣銆佹斁璐т换鍔″悓鏃朵笅鍙�
+            WrkMast wrkMast1 = wrkMastTask.get(0);
+            WrkMast wrkMast2 = wrkMastTask.get(1);
+            if(Cools.isEmpty(wrkMast1) || Cools.isEmpty(wrkMast2)){
+                log.error("宸ヤ綔妗GV鍏ュ簱鏁版嵁涓虹┖");
+                return;
+            }
+            //  鍛戒护涓嬪彂鍖� --------------------------------------------------------------------------
+            RgvCommand rgvCommand = new RgvCommand();
+            rgvCommand.setRgvNo(slave.getId()); // RGV缂栧彿
+            rgvCommand.setAckFinish1((short) 0);  // 宸ヤ綅1浠诲姟瀹屾垚纭浣�
+            rgvCommand.setTaskNo1(wrkMast1.getWrkNo().shortValue()); // 宸ヤ綅1宸ヤ綔鍙�
+            rgvCommand.setTaskMode1(RgvTaskModeType.FETCH_PUT); // 宸ヤ綅1浠诲姟妯″紡:  鍙栨斁璐�
+            rgvCommand.setSourceStaNo1(wrkMast1.getRgvSstaNo().shortValue());   //宸ヤ綅1婧愮珯鐐�
+            rgvCommand.setDestinationStaNo1(wrkMast1.getRgvDstaNo().shortValue());   //宸ヤ綅1鐩爣绔欑偣
+            rgvCommand.setAckFinish2((short) 0);  // 宸ヤ綅2浠诲姟瀹屾垚纭浣�
+            rgvCommand.setTaskNo2(wrkMast2.getWrkNo().shortValue()); // 宸ヤ綅2宸ヤ綔鍙�
+            rgvCommand.setTaskMode2(RgvTaskModeType.FETCH_PUT); // 宸ヤ綅2浠诲姟妯″紡:  鍙栨斁璐�
+            rgvCommand.setSourceStaNo2(wrkMast2.getRgvSstaNo().shortValue());   //宸ヤ綅2婧愮珯鐐�
+            rgvCommand.setDestinationStaNo2(wrkMast2.getRgvDstaNo().shortValue());   //宸ヤ綅2鐩爣绔欑偣
+            rgvCommand.setCommand((short) 0);   //宸ヤ綅1銆�2浠诲姟纭
+            if (!MessageQueue.offer(SlaveType.Crn, wrkMast1.getRgvNo(), new Task(2, rgvCommand))) {
+                //step=2,宸ヤ綅1銆�2鍐欎换鍔★紱   step=4锛屽伐浣�1鍐欎换鍔★紱     step=5锛屽伐浣�2鍐欎换鍔�
+                log.error("RGV鍛戒护涓嬪彂澶辫触锛孯GV鍙�={}锛屼换鍔℃暟鎹�={}", slave.getId(), JSON.toJSON(rgvCommand));
+            } else {
+                // 淇敼宸ヤ綔妗g姸鎬� 14.鍑哄簱瀹屾垚 => 16.RGV鍑哄簱鍙栬揣涓�
+                Date now = new Date();
+                wrkMast1.setWrkSts(16L);
+                wrkMast1.setCrnStrTime(now);
+                wrkMast1.setModiTime(now);
+                if (wrkMastMapper.updateById(wrkMast1) == 0) {
+                    log.error("淇敼宸ヤ綔妗g姸鎬� 14.鍑哄簱瀹屾垚 => 16.RGV鍑哄簱鍙栬揣涓� 澶辫触锛侊紒锛屽伐浣滃彿={}", wrkMast1.getWrkNo());
+                }
+
+                wrkMast2.setWrkSts(16L);
+                wrkMast2.setCrnStrTime(now);
+                wrkMast2.setModiTime(now);
+                if (wrkMastMapper.updateById(wrkMast2) == 0) {
+                    log.error("淇敼宸ヤ綔妗g姸鎬� 14.鍑哄簱瀹屾垚 => 16.RGV鍑哄簱鍙栬揣涓� 澶辫触锛侊紒锛屽伐浣滃彿={}", wrkMast2.getWrkNo());
+                }
+            }
+        } else if(wrkMastTask.size() == 1){
+            //鍙湁1绗擱GV寰呭叆搴撲换鍔★紝鍏堜笅鍙戝彇璐т换鍔★紝鍙栬揣鍚庡啀鍒ゆ柇鏄惁鏈変笅涓�绗斿緟鍏ュ簱浠诲姟
+            WrkMast wrkMast1 = wrkMastTask.get(0);
+            if(Cools.isEmpty(wrkMast1)){
+                log.error("宸ヤ綔妗GV鍏ュ簱鏁版嵁涓虹┖");
+                return;
+            }
+            //  鍛戒护涓嬪彂鍖� --------------------------------------------------------------------------
+            RgvCommand rgvCommand = new RgvCommand();
+            rgvCommand.setRgvNo(slave.getId()); // RGV缂栧彿
+            rgvCommand.setAckFinish1((short) 0);  // 宸ヤ綅1浠诲姟瀹屾垚纭浣�
+            rgvCommand.setTaskNo1(wrkMast1.getWrkNo().shortValue()); // 宸ヤ綅1宸ヤ綔鍙�
+            rgvCommand.setTaskMode1(RgvTaskModeType.FETCH); // 宸ヤ綅1浠诲姟妯″紡:  鍙栬揣
+            rgvCommand.setSourceStaNo1(wrkMast1.getRgvSstaNo().shortValue());   //宸ヤ綅1婧愮珯鐐�
+            rgvCommand.setDestinationStaNo1(wrkMast1.getRgvDstaNo().shortValue());   //宸ヤ綅1鐩爣绔欑偣
+            rgvCommand.setCommand((short) 0);   //宸ヤ綅1銆�2浠诲姟纭
+            if (!MessageQueue.offer(SlaveType.Crn, wrkMast1.getRgvNo(), new Task(4, rgvCommand))) {
+                //step=2,宸ヤ綅1銆�2浠诲姟纭锛�   step=4锛屽伐浣�1纭锛�     step=5锛屽伐浣�2浠诲姟纭
+                log.error("RGV鍛戒护涓嬪彂澶辫触锛孯GV鍙�={}锛屼换鍔℃暟鎹�={}", slave.getId(), JSON.toJSON(rgvCommand));
+            } else {
+                // 淇敼宸ヤ綔妗g姸鎬� 14.鍑哄簱瀹屾垚 => 16.RGV鍑哄簱鍙栬揣涓�
+                Date now = new Date();
+                wrkMast1.setWrkSts(16L);
+                wrkMast1.setCrnStrTime(now);
+                wrkMast1.setModiTime(now);
+                if (wrkMastMapper.updateById(wrkMast1) == 0) {
+                    log.error("淇敼宸ヤ綔妗g姸鎬� 14.鍑哄簱瀹屾垚 => 16.RGV鍑哄簱鍙栬揣涓� 澶辫触锛侊紒锛屽伐浣滃彿={}", wrkMast1.getWrkNo());
+                }
+            }
+        }
+    }
+
+    /**
+     * 鏌ユ壘宸ヤ綔鐘舵�佷负14锛堝嚭搴撳畬鎴愶級,涓擱GV鍑哄簱鎺ラ┏绔欑鍚堢殑鐨勫嚭搴撳伐浣滄。锛屾彁鍙栧嚭鏈�澶�2绗�
+     * @param slave
+     * @return
+     */
+    public synchronized List<WrkMast> getRgvOutTask(RgvSlave slave){
+        List<WrkMast> wrkMastTask = new ArrayList<>();
+        List<Integer> staNos = new ArrayList<>();
+        for (RgvSlave.RgvStn rgvStn : slave.getRgvOutSStn()) {
+            staNos.add(rgvStn.getStaNo());
+        }
+        if(staNos.size() < 1){
+            return null;
+        }
+        List<WrkMast> wrkMasts = wrkMastMapper.selectRgvOutStep1(slave.getId(), staNos);
+        for(WrkMast wrkMast : wrkMasts){
+            Integer plcId = 0;
+            for (RgvSlave.RgvStn rgvStn : slave.getRgvOutSStn()) {
+                if(rgvStn.getStaNo() == wrkMast.getRgvSstaNo()){
+                    plcId = rgvStn.getDevpPlcId();
+                    break;
+                }
+            }
+
+            DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, plcId);
+            //鍒ゆ柇RGV鍑哄簱婧愮珯鐐癸紝鑷姩銆佹湁鐗╋紝鏈変换鍔″彿锛屽彲鍑�
+            boolean flag1 = false;
+            StaProtocol staProtocol1 = devpThread.getStation().get(wrkMast.getRgvSstaNo());
+            if (staProtocol1 == null) {
+                continue;
+            } else {
+                staProtocol1 = staProtocol1.clone();
+            }
+            // 鏌ヨ绔欑偣璇︾粏淇℃伅
+            BasDevp staDetl1 = basDevpService.selectById(wrkMast.getRgvSstaNo());
+            if (staDetl1 == null) {
+                log.error("RGV鍑哄簱 ===>> 杈撻�佹満婧愮珯鐐瑰湪鏁版嵁搴撲笉瀛樺湪, 绔欑偣缂栧彿={}", wrkMast.getRgvSstaNo());
+                continue;
+            }
+            if (staProtocol1.isAutoing() && staProtocol1.isLoading() && staProtocol1.getWorkNo().intValue() == wrkMast.getWrkNo()
+                    && staProtocol1.isOutEnable() && staDetl1.getOutEnable() != null && staDetl1.getOutEnable().equals("Y")) {
+                flag1 = true;
+            }
+
+            //鍒ゆ柇RGV鍑哄簱鐩爣绔欑偣锛岃嚜鍔ㄣ�佹棤鐗╋紝娌℃湁浠诲姟鍙凤紝鍙叆
+            boolean flag2 = false;
+            StaProtocol staProtocol2 = devpThread.getStation().get(wrkMast.getRgvDstaNo());
+            if (staProtocol2 == null) {
+                continue;
+            } else {
+                staProtocol2 = staProtocol2.clone();
+            }
+            // 鏌ヨ绔欑偣璇︾粏淇℃伅
+            BasDevp staDetl2 = basDevpService.selectById(wrkMast.getRgvSstaNo());
+            if (staDetl2 == null) {
+                log.error("RGV鍑哄簱 ===>> 杈撻�佹満婧愮珯鐐瑰湪鏁版嵁搴撲笉瀛樺湪, 绔欑偣缂栧彿={}", wrkMast.getRgvSstaNo());
+                continue;
+            }
+            if (staProtocol2.isAutoing() && staProtocol2.isLoading() && staProtocol2.getWorkNo().intValue() == wrkMast.getWrkNo()
+                    && staProtocol2.isInEnable() && staDetl2.getCanining() != null && staDetl2.getCanining().equals("Y")) {
+                flag2 = true;
+            }
+
+            if(flag1 && flag2){
+                wrkMastTask.add(wrkMast);
+                if(wrkMastTask.size() >= 2) break;
+            }
+        }
+        return wrkMastTask;
+    }
+
+    /**
+     * 鏍规嵁RGV瀹屾垚淇″彿锛屾墽琛屽宸ヤ綔妗g殑瀹屾垚鎿嶄綔锛屽拰RGV鐨勪换鍔′笅鍙�
+     */
+    public synchronized void rgvFinished() {
+        for (RgvSlave rgv : slaveProperties.getRgv()) {
+            // 鑾峰彇RGV淇℃伅
+            RgvThread rgvThread = (RgvThread) SlaveConnection.get(SlaveType.Rgv, rgv.getId());
+            RgvProtocol rgvProtocol = rgvThread.getRgvProtocol();
+            if (rgvProtocol == null) {
+                continue;
+            }
+            //  宸ヤ綅1鐘舵�侊細鍙栬揣瀹屾垚绛夊緟纭91 骞朵笖  浠诲姟瀹屾垚浣� = 1
+            if (rgvProtocol.statusType1 == RgvStatusType.FETCHWAITING && rgvProtocol.getTaskNo1() != 0) {
+                //宸ヤ綅1鍙栬揣瀹屾垚鍚庯紝宸ヤ綅2鏄棤璐х┖闂茬姸鎬佹椂锛屽噯澶囩粰宸ヤ綅2鍙戜换鍔★紝纭鏄惁鏈夊緟鎵цRGV浠诲姟
+                if (rgvProtocol.getModeType() == RgvModeType.AUTO
+                        && rgvProtocol.getTaskNo1() > 0 && rgvProtocol.getTaskNo2() == 0
+                        && rgvProtocol.getLoaded1() > 0 && rgvProtocol.getLoaded2() == 0
+                        && rgvProtocol.getStatusType2() == RgvStatusType.IDLE
+                ) {
+                    WrkMast wrkMast1 = wrkMastMapper.selectPakInStep3(rgvProtocol.getTaskNo1().intValue());
+                    if (wrkMast1 == null) {
+                        log.error("RGV宸ヤ綅1澶勪簬绛夊緟纭涓斿彇璐т换鍔″畬鎴愮姸鎬侊紝浣嗘湭鎵惧埌宸ヤ綔妗c�俁GV鍙�={}锛屽伐浣滃彿={}", rgv.getId(), rgvProtocol.getTaskNo1());
+                        continue;
+                    }
+                    List<WrkMast> wrkMastTask = new ArrayList<>();
+                    List<WrkMast> list = new ArrayList<>();
+                    Integer type = 0;//1鍏ュ簱锛�2鍑哄簱
+                    if(wrkMast1.getWrkSts()==6L){
+                        wrkMastTask = getRgvInTask(rgv);
+                        list = wrkMastMapper.selectRgvInWorking(rgv.getId());
+                        type = 1;
+                    } else if(wrkMast1.getWrkSts()==16L){
+                        wrkMastTask = getRgvOutTask(rgv);
+                        list = wrkMastMapper.selectRgvOutWorking(rgv.getId());
+                        type = 2;
+                    }
+                    if(wrkMastTask.size() > 0){//鏈夌户缁墽琛屼换鍔★紝涓嬪彂鍙栬揣浠诲姟缁欏伐浣�2
+                        // 宸茬粡瀛樺湪RGV鎵ц浠诲姟鏃讹紝鍒欒繃婊�
+                        if (list.size() > 1) {
+                            continue;
+                        }
+                        WrkMast wrkMast2 = wrkMastTask.get(0);
+                        //  鍛戒护涓嬪彂鍖� --------------------------------------------------------------------------
+                        RgvCommand rgvCommand = new RgvCommand();
+                        rgvCommand.setRgvNo(rgv.getId()); // RGV缂栧彿
+                        rgvCommand.setAckFinish2((short) 0);  // 宸ヤ綅2浠诲姟瀹屾垚纭浣�
+                        rgvCommand.setTaskNo2(wrkMast2.getWrkNo().shortValue()); // 宸ヤ綅2宸ヤ綔鍙�
+                        rgvCommand.setTaskMode2(RgvTaskModeType.FETCH); // 宸ヤ綅2浠诲姟妯″紡:  鍙栬揣
+                        rgvCommand.setSourceStaNo2(wrkMast2.getRgvSstaNo().shortValue());   //宸ヤ綅2婧愮珯鐐�
+                        rgvCommand.setDestinationStaNo2(wrkMast2.getRgvDstaNo().shortValue());   //宸ヤ綅2鐩爣绔欑偣
+                        rgvCommand.setCommand((short) 0);   //宸ヤ綅1銆�2浠诲姟纭
+                        if (!MessageQueue.offer(SlaveType.Crn, wrkMast2.getRgvNo(), new Task(5, rgvCommand))) {
+                            //step=2,宸ヤ綅1銆�2鍐欎换鍔★紱   step=4锛屽伐浣�1鍐欎换鍔★紱     step=5锛屽伐浣�2鍐欎换鍔�
+                            log.error("RGV鍛戒护涓嬪彂澶辫触锛孯GV鍙�={}锛屼换鍔℃暟鎹�={}", rgv.getId(), JSON.toJSON(rgvCommand));
+                        } else {
+                            // 淇敼宸ヤ綔妗g姸鎬� 2.璁惧涓婅蛋 => 6.RGV鍏ュ簱鍙栬揣涓�
+                            Date now = new Date();
+                            wrkMast2.setWrkSts(type==1 ? 6L : 16L);
+                            wrkMast2.setCrnStrTime(now);
+                            wrkMast2.setModiTime(now);
+                            if (wrkMastMapper.updateById(wrkMast2) == 0) {
+                                log.error("宸ヤ綅2淇敼宸ヤ綔妗g姸鎬� 2/14.璁惧涓婅蛋 => 6/16.RGV鍏ュ簱鍙栬揣涓� 澶辫触锛侊紒锛屽伐浣滃彿={}", wrkMast2.getWrkNo());
+                            }
+                        }
+                    } else {//娌℃湁缁х画鎵ц浠诲姟锛屼笅鍙戞斁璐т换鍔$粰宸ヤ綅1
+                        if(type == 1 && wrkMast1.getWrkSts() != 6L){//RGV鍏ュ簱鍙栬揣涓�
+                            continue;
+                        }
+                        if(type == 2 && wrkMast1.getWrkSts() != 16L){//RGV鍑哄簱鍙栬揣涓�
+                            continue;
+                        }
+
+                        //  鍛戒护涓嬪彂鍖� --------------------------------------------------------------------------
+                        RgvCommand rgvCommand = new RgvCommand();
+                        rgvCommand.setRgvNo(rgv.getId()); // RGV缂栧彿
+                        rgvCommand.setAckFinish1((short) 0);  // 宸ヤ綅1浠诲姟瀹屾垚纭浣�
+                        rgvCommand.setTaskNo1(wrkMast1.getWrkNo().shortValue()); // 宸ヤ綅1宸ヤ綔鍙�
+                        rgvCommand.setTaskMode1(RgvTaskModeType.PUT); // 宸ヤ綅1浠诲姟妯″紡:  鏀捐揣
+                        rgvCommand.setSourceStaNo1(wrkMast1.getRgvSstaNo().shortValue());   //宸ヤ綅1婧愮珯鐐�
+                        rgvCommand.setDestinationStaNo1(wrkMast1.getRgvDstaNo().shortValue());   //宸ヤ綅1鐩爣绔欑偣
+                        rgvCommand.setCommand((short) 0);   //宸ヤ綅1銆�2浠诲姟纭
+                        if (!MessageQueue.offer(SlaveType.Crn, wrkMast1.getRgvNo(), new Task(4, rgvCommand))) {
+                            //step=2,宸ヤ綅1銆�2浠诲姟纭锛�   step=4锛屽伐浣�1纭锛�     step=5锛屽伐浣�2浠诲姟纭
+                            log.error("RGV鍛戒护涓嬪彂澶辫触锛孯GV鍙�={}锛屼换鍔℃暟鎹�={}", rgv.getId(), JSON.toJSON(rgvCommand));
+                        } else {
+                            // 淇敼宸ヤ綔妗g姸鎬� 6.RGV鍏ュ簱鍙栬揣涓� => 7.RGV鍏ュ簱鏀捐揣涓�
+                            Date now = new Date();
+                            wrkMast1.setWrkSts(type==1 ? 7L : 17L);
+                            wrkMast1.setCrnEndTime(now);
+                            wrkMast1.setModiTime(now);
+                            if (wrkMastMapper.updateById(wrkMast1) == 0) {
+                                log.error("淇敼宸ヤ綔妗g姸鎬� 6/16.RGV鍏ュ簱鍙栬揣涓� => 7/17.RGV鍏ュ簱鏀捐揣涓� 澶辫触锛侊紒锛屽伐浣滃彿={}", wrkMast1.getWrkNo());
+                            }
+                            log.error("RGV鍛戒护涓嬪彂鎴愬姛锛孯GV鍙�={}锛屼换鍔℃暟鎹�={}", rgv.getId(), JSON.toJSON(rgvCommand));
+                        }
+                    }
+                } else if (rgvProtocol.getModeType() == RgvModeType.AUTO
+                        && rgvProtocol.getTaskNo1() > 0 && rgvProtocol.getTaskNo2() > 0
+                        && rgvProtocol.getLoaded1() > 0 && rgvProtocol.getLoaded2() > 0
+                        && rgvProtocol.statusType2 == RgvStatusType.FETCHWAITING){
+                    //  宸ヤ綅2鐘舵�侊細涔熸槸鍙栬揣瀹屾垚绛夊緟纭91 骞朵笖  浠诲姟瀹屾垚浣� = 1,  宸ヤ綅1銆�2鍚屾椂涓嬪彂鏀捐揣浠诲姟
+                    WrkMast wrkMast1 = wrkMastMapper.selectPakInStep3(rgvProtocol.getTaskNo1().intValue());
+                    WrkMast wrkMast2 = wrkMastMapper.selectPakInStep3(rgvProtocol.getTaskNo2().intValue());
+                    //  鍛戒护涓嬪彂鍖� --------------------------------------------------------------------------
+                    RgvCommand rgvCommand = new RgvCommand();
+                    rgvCommand.setRgvNo(rgv.getId()); // RGV缂栧彿
+                    rgvCommand.setAckFinish1((short) 0);  // 宸ヤ綅1浠诲姟瀹屾垚纭浣�
+                    rgvCommand.setTaskNo1(wrkMast1.getWrkNo().shortValue()); // 宸ヤ綅1宸ヤ綔鍙�
+                    rgvCommand.setTaskMode1(RgvTaskModeType.PUT); // 宸ヤ綅1浠诲姟妯″紡:  鏀捐揣
+                    rgvCommand.setSourceStaNo1(wrkMast1.getRgvSstaNo().shortValue());   //宸ヤ綅1婧愮珯鐐�
+                    rgvCommand.setDestinationStaNo1(wrkMast1.getRgvDstaNo().shortValue());   //宸ヤ綅1鐩爣绔欑偣
+                    rgvCommand.setAckFinish2((short) 0);  // 宸ヤ綅2浠诲姟瀹屾垚纭浣�
+                    rgvCommand.setTaskNo2(wrkMast2.getWrkNo().shortValue()); // 宸ヤ綅2宸ヤ綔鍙�
+                    rgvCommand.setTaskMode2(RgvTaskModeType.PUT); // 宸ヤ綅2浠诲姟妯″紡:  鏀捐揣
+                    rgvCommand.setSourceStaNo2(wrkMast2.getRgvSstaNo().shortValue());   //宸ヤ綅2婧愮珯鐐�
+                    rgvCommand.setDestinationStaNo2(wrkMast2.getRgvDstaNo().shortValue());   //宸ヤ綅2鐩爣绔欑偣
+                    rgvCommand.setCommand((short) 0);   //宸ヤ綅1銆�2浠诲姟纭
+                    if (!MessageQueue.offer(SlaveType.Crn, wrkMast1.getRgvNo(), new Task(2, rgvCommand))) {
+                        //step=2,宸ヤ綅1銆�2浠诲姟纭锛�   step=4锛屽伐浣�1纭锛�     step=5锛屽伐浣�2浠诲姟纭
+                        log.error("RGV鍛戒护涓嬪彂澶辫触锛孯GV鍙�={}锛屼换鍔℃暟鎹�={}", rgv.getId(), JSON.toJSON(rgvCommand));
+                    } else {
+                        // 淇敼宸ヤ綔妗g姸鎬� 2.璁惧涓婅蛋 => 6.RGV鍏ュ簱鍙栬揣涓�
+                        Date now = new Date();
+                        wrkMast1.setWrkSts(wrkMast1.getWrkSts()==6L ? 7L : 17L);
+                        wrkMast1.setCrnStrTime(now);
+                        wrkMast1.setModiTime(now);
+                        if (wrkMastMapper.updateById(wrkMast1) == 0) {
+                            log.error("淇敼宸ヤ綔妗g姸鎬� 6/16.RGV鍏ュ簱鍙栬揣涓� => 7/17.RGV鍏ュ簱鏀捐揣涓� 澶辫触锛侊紒锛屽伐浣滃彿={}", wrkMast1.getWrkNo());
+                        }
+
+                        wrkMast2.setWrkSts(wrkMast2.getWrkSts()==6L ? 7L : 17L);
+                        wrkMast2.setCrnStrTime(now);
+                        wrkMast2.setModiTime(now);
+                        if (wrkMastMapper.updateById(wrkMast2) == 0) {
+                            log.error("淇敼宸ヤ綔妗g姸鎬� 6/16.RGV鍏ュ簱鍙栬揣涓� => 7/17.RGV鍏ュ簱鏀捐揣涓� 澶辫触锛侊紒锛屽伐浣滃彿={}", wrkMast2.getWrkNo());
+                        }
+                    }
+                }
+            }
+
+        }
+    }
+
+    /**
+     * 鍏ュ簱  ===>>  RGV鍑哄簱绔欏埌鍫嗗灈鏈哄叆搴撶珯
+     * rgvInDStnToCrnStn
+     */
+    public synchronized void rgvDestStnToCrnStn() {
+        for (RgvSlave rgvSlave : slaveProperties.getRgv()) {
+            // 閬嶅巻鍏ュ簱浠诲姟鐨凴GV鍑哄簱绔�
+            for (RgvSlave.RgvStn rgvStn : rgvSlave.getRgvDestStn()) {
+                // 鑾峰彇RGV鍑哄簱绔欎俊鎭�
+                DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, rgvStn.getDevpPlcId());
+                StaProtocol staProtocol = devpThread.getStation().get(rgvStn.getStaNo());
+                if (staProtocol == null) {
+                    continue;
+                } else {
+                    staProtocol = staProtocol.clone();
+                }
+                if (staProtocol.isAutoing() && staProtocol.isLoading() && (staProtocol.getWorkNo() == 0 || staProtocol.getStaNo() == null)) {
+                    // 鏌ヨ宸ヤ綔妗ist
+//                    List<WrkMast> wrkMasts = wrkMastMapper.selectRgvInStep2(staProtocol.getSiteId());
+                    List<WrkMast> wrkMasts = wrkMastMapper.selectRgvDestStep2(staProtocol.getSiteId());
+                    for(WrkMast wrkMast : wrkMasts){
+                        // 鍒ゆ柇宸ヤ綔妗f潯浠�
+                        if (wrkMast.getStaNo() == null || wrkMast.getSourceStaNo() == null
+                            || wrkMast.getRgvSstaNo() == null || wrkMast.getRgvDstaNo() == null) {
+                            continue;
+                        }
+
+                        RgvThread rgvThread = (RgvThread) SlaveConnection.get(SlaveType.Rgv, wrkMast.getRgvNo());
+                        RgvProtocol rgvProtocol = rgvThread.getRgvProtocol();
+                        //  鍒ゆ柇RGV鐘舵�佺瓑寰呯‘璁�,宸ヤ綅1
+                        if (rgvProtocol.modeType == RgvModeType.AUTO && rgvProtocol.getTaskNo1().equals(wrkMast.getWrkNo().shortValue())
+                                && rgvProtocol.statusType1 == RgvStatusType.WAITING) {
+                            // 鍛戒护涓嬪彂鍖� --------------------------------------------------------------------------
+                            // 涓嬪彂绔欑偣淇℃伅
+                            staProtocol.setWorkNo(wrkMast.getWrkNo().shortValue());
+                            staProtocol.setStaNo(wrkMast.getStaNo().shortValue());
+                            if (!MessageQueue.offer(SlaveType.Devp, rgvStn.getDevpPlcId(), new Task(2, staProtocol))) {
+                                continue;
+                            }
+                            // 鏇存柊宸ヤ綔妗g姸鎬佷负2,14
+                            wrkMast.setWrkSts(wrkMast.getWrkSts()==7L ? 2L : 14L);
+                            wrkMast.setOnlineYn("Y");
+                            wrkMast.setCrnEndTime(new Date());
+                            if (wrkMastMapper.updateById(wrkMast) != 0) {
+                                // 澶嶄綅RGV宸ヤ綅1
+                                rgvThread.setResetFlag1(true);
+                            } else {
+                                log.error("RGV宸ヤ綅1鎺ラ┏锛屾洿鏂板伐浣滄。鐨勫伐浣滅姸鎬佷负{}澶辫触锛侊紒锛� [宸ヤ綔鍙�:{}]", wrkMast.getWrkSts()==7L ? 2L : 14L, wrkMast.getWrkNo());
+                            }
+                        }
+                        //  鍒ゆ柇RGV鐘舵�佺瓑寰呯‘璁�,宸ヤ綅2
+                        if (rgvProtocol.modeType == RgvModeType.AUTO && rgvProtocol.getTaskNo2().equals(wrkMast.getWrkNo().shortValue())
+                                && rgvProtocol.statusType2 == RgvStatusType.WAITING) {
+                            // 鍛戒护涓嬪彂鍖� --------------------------------------------------------------------------
+                            // 涓嬪彂绔欑偣淇℃伅
+                            staProtocol.setWorkNo(wrkMast.getWrkNo().shortValue());
+                            staProtocol.setStaNo(wrkMast.getStaNo().shortValue());
+                            if (!MessageQueue.offer(SlaveType.Devp, rgvStn.getDevpPlcId(), new Task(2, staProtocol))) {
+                                continue;
+                            }
+                            // 鏇存柊宸ヤ綔妗g姸鎬佷负2,14
+                            wrkMast.setWrkSts(wrkMast.getWrkSts()==7L ? 2L : 14L);
+                            wrkMast.setOnlineYn("Y");
+                            wrkMast.setCrnEndTime(new Date());
+                            if (wrkMastMapper.updateById(wrkMast) != 0) {
+                                // 澶嶄綅RGV宸ヤ綅2
+                                rgvThread.setResetFlag2(true);
+                            } else {
+                                log.error("RGV宸ヤ綅2鎺ラ┏锛屾洿鏂板伐浣滄。鐨勫伐浣滅姸鎬佷负{}澶辫触锛侊紒锛� [宸ヤ綔鍙�:{}]", wrkMast.getWrkSts()==7L ? 2L : 14L, wrkMast.getWrkNo());
+                            }
+                        }
+                    }
+
+                }
+            }
+        }
+    }
+
+    /**
+     * 鍑哄簱  ===>>  RGV鍑哄簱绔欏埌绯荤粺鍑哄簱绔�
+     */
+    public synchronized void rgvOutDStnToOutStn() {
+        for (RgvSlave rgvSlave : slaveProperties.getRgv()) {
+            // 閬嶅巻鍑哄簱浠诲姟鐨凴GV鍑哄簱绔�
+            for (RgvSlave.RgvStn rgvStn : rgvSlave.getRgvDestStn()) {
+                // 鑾峰彇RGV鍑哄簱绔欎俊鎭�
+                DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, rgvStn.getDevpPlcId());
+                StaProtocol staProtocol = devpThread.getStation().get(rgvStn.getStaNo());
+                if (staProtocol == null) {
+                    continue;
+                } else {
+                    staProtocol = staProtocol.clone();
+                }
+                if (staProtocol.isAutoing() && staProtocol.isLoading() && (staProtocol.getWorkNo() == 0 || staProtocol.getStaNo() == null)) {
+                    // 鏌ヨ宸ヤ綔妗ist
+                    List<WrkMast> wrkMasts = wrkMastMapper.selectRgvOutStep2(staProtocol.getSiteId());
+                    for(WrkMast wrkMast : wrkMasts){
+                        // 鍒ゆ柇宸ヤ綔妗f潯浠�
+                        if (wrkMast.getIoType() < 100 || wrkMast.getStaNo() == null || wrkMast.getSourceStaNo() == null
+                                || wrkMast.getRgvSstaNo() == null || wrkMast.getRgvDstaNo() == null) {
+                            continue;
+                        }
+
+                        RgvThread rgvThread = (RgvThread) SlaveConnection.get(SlaveType.Rgv, wrkMast.getRgvNo());
+                        RgvProtocol rgvProtocol = rgvThread.getRgvProtocol();
+                        //  鍒ゆ柇RGV鐘舵�佺瓑寰呯‘璁�,宸ヤ綅1
+                        if (rgvProtocol.modeType == RgvModeType.AUTO && rgvProtocol.getTaskNo1().equals(wrkMast.getWrkNo().shortValue())
+                                && rgvProtocol.statusType1 == RgvStatusType.WAITING) {
+                            // 鍛戒护涓嬪彂鍖� --------------------------------------------------------------------------
+                            // 涓嬪彂绔欑偣淇℃伅
+                            staProtocol.setWorkNo(wrkMast.getWrkNo().shortValue());
+                            staProtocol.setStaNo(wrkMast.getStaNo().shortValue());
+                            if (!MessageQueue.offer(SlaveType.Devp, rgvStn.getDevpPlcId(), new Task(2, staProtocol))) {
+                                continue;
+                            }
+                            // 鏇存柊宸ヤ綔妗g姸鎬佷负14
+                            wrkMast.setWrkSts(14L);
+                            wrkMast.setOnlineYn("Y");   //鎺у埗WMS灏嗗伐浣滅姸鎬�14杞�15鐨勬椂鏈猴紝鍙湁RGV杩愭惉瀹屾垚鍚庢墠鍙互杞�
+                            wrkMast.setCrnEndTime(new Date());
+                            if (wrkMastMapper.updateById(wrkMast) != 0) {
+                                // 澶嶄綅RGV宸ヤ綅1
+                                rgvThread.setResetFlag1(true);
+                            } else {
+                                log.error("RGV宸ヤ綅1鎺ラ┏锛屾洿鏂板伐浣滄。鐨勫伐浣滅姸鎬佷负2澶辫触锛侊紒锛� [宸ヤ綔鍙�:{}]", wrkMast.getWrkNo());
+                            }
+                        }
+                        //  鍒ゆ柇RGV鐘舵�佺瓑寰呯‘璁�,宸ヤ綅2
+                        if (rgvProtocol.modeType == RgvModeType.AUTO && rgvProtocol.getTaskNo2().equals(wrkMast.getWrkNo().shortValue())
+                                && rgvProtocol.statusType2 == RgvStatusType.WAITING) {
+                            // 鍛戒护涓嬪彂鍖� --------------------------------------------------------------------------
+                            // 涓嬪彂绔欑偣淇℃伅
+                            staProtocol.setWorkNo(wrkMast.getWrkNo().shortValue());
+                            staProtocol.setStaNo(wrkMast.getStaNo().shortValue());
+                            if (!MessageQueue.offer(SlaveType.Devp, rgvStn.getDevpPlcId(), new Task(2, staProtocol))) {
+                                continue;
+                            }
+                            // 鏇存柊宸ヤ綔妗g姸鎬佷负14
+                            wrkMast.setWrkSts(14L);
+                            wrkMast.setOnlineYn("Y");   //鎺у埗WMS灏嗗伐浣滅姸鎬�14杞�15鐨勬椂鏈猴紝鍙湁RGV杩愭惉瀹屾垚鍚庢墠鍙互杞�
+                            wrkMast.setCrnEndTime(new Date());
+                            if (wrkMastMapper.updateById(wrkMast) != 0) {
+                                // 澶嶄綅RGV宸ヤ綅2
+                                rgvThread.setResetFlag2(true);
+                            } else {
+                                log.error("RGV宸ヤ綅2鎺ラ┏锛屾洿鏂板伐浣滄。鐨勫伐浣滅姸鎬佷负2澶辫触锛侊紒锛� [宸ヤ綔鍙�:{}]", wrkMast.getWrkNo());
+                            }
+                        }
+                    }
+
+                }
+            }
+        }
     }
 
     /**
@@ -1283,8 +1695,7 @@
     /**
      * 鎵ц瀵瑰伐浣滄。鐨勫畬鎴愭搷浣�
      */
-    @Async
-    public void storeFinished() {
+    public synchronized void storeFinished() {
         for (CrnSlave crn : slaveProperties.getCrn()) {
             // 鑾峰彇鍫嗗灈鏈轰俊鎭�
             CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, crn.getId());
@@ -1327,8 +1738,7 @@
     /**
      * 鍫嗗灈鏈哄紓甯镐俊鎭褰�
      */
-    @Async
-    public void recCrnErr() {
+    public synchronized void recCrnErr() {
         Date now = new Date();
         for (CrnSlave crn : slaveProperties.getCrn()) {
             // 鑾峰彇鍫嗗灈鏈轰俊鎭�
@@ -1449,8 +1859,7 @@
     /**
      * 绌烘爤鏉垮垵濮嬪寲鍏ュ簱,鍙夎溅鍏ュ簱绔欐斁璐�
      */
-    @Async
-    public void storeEmptyPlt() {
+    public synchronized void storeEmptyPlt() {
         for (DevpSlave devp : slaveProperties.getDevp()) {
             // 閬嶅巻绌烘澘鍏ュ簱鍙�
             for (DevpSlave.Sta emptyInSta : devp.getEmptyInSta()) {
@@ -1564,8 +1973,7 @@
     /**
      * 鍑哄簱  ===>> 宸ヤ綔妗d俊鎭啓鍏ed鏄剧ず鍣�
      */
-    @Async
-    public void ledExecute() {
+    public synchronized void ledExecute() {
         for (LedSlave led : slaveProperties.getLed()) {
             // 鑾峰彇杈撻�佺嚎plc绾跨▼
             DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, led.getDevpPlcId());
@@ -1681,35 +2089,7 @@
     /**
      * 鍏朵粬  ===>> LED鏄剧ず鍣ㄥ浣嶏紝鏄剧ず榛樿淇℃伅
      */
-    @Async
-    public void ledReset() {
-//        for (LedSlave led : slaveProperties.getLed()) {
-//            // 鑾峰彇杈撻�佺嚎plc绾跨▼
-//            DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, led.getDevpPlcId());
-//            // 鍛戒护闆嗗悎
-//            boolean reset = true;
-//            for (Integer staNo : led.getStaArr()) {
-//                // 鑾峰彇鍙夎溅绔欑偣
-//                StaProtocol staProtocol = devpThread.getStation().get(staNo);
-//                if (staProtocol == null) {
-//                    continue;
-//                } else {
-//                    staProtocol = staProtocol.clone();
-//                }
-//                if (staProtocol.getWorkNo() != 0) {
-//                    reset = false;
-//                    break;
-//                }
-//            }
-//            // 鑾峰彇led绾跨▼
-//            LedThread ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, led.getDevpPlcId());
-//            // led鏄剧ず榛樿鍐呭
-//            if (reset) {
-//                if (!MessageQueue.offer(SlaveType.Led, led.getId(), new Task(2, new ArrayList<>()))) {
-//                    log.error("{}鍙稬ED鍛戒护涓嬪彂澶辫触锛侊紒锛乕ip锛歿}] [port锛歿}]", led.getId(), led.getIp(), led.getPort());
-//                }
-//            }
-//        }
+    public synchronized void ledReset() {
         for (LedSlave led : slaveProperties.getLed()) {
             // 鑾峰彇杈撻�佺嚎plc绾跨▼
             DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, led.getDevpPlcId());
diff --git a/src/main/java/com/zy/core/MainProcess.java b/src/main/java/com/zy/core/MainProcess.java
index e62ae2a..9634d57 100644
--- a/src/main/java/com/zy/core/MainProcess.java
+++ b/src/main/java/com/zy/core/MainProcess.java
@@ -56,12 +56,22 @@
                     mainService.crnStnToOutStn();
                     // 鍏ュ嚭搴�  ===>>  鍫嗗灈鏈哄叆鍑哄簱浣滀笟涓嬪彂
                     mainService.crnIoExecute();
-                        // 鍏ュ嚭搴�  ===>>  RGV鍏ュ嚭搴撲綔涓氫笅鍙�
-                    mainService.rgvIoExecute();
                     // 鍏ュ嚭搴撳寮� ===>> 鍫嗗灈鏈哄懡浠や笅鍙戝悗锛屽紓姝ヤ慨鏀瑰伐浣滄。鐘舵��
 //                    mainService.crnIoWrkMast();
                     // 鍏ュ簱  ===>> 鎵ц瀵瑰伐浣滄。鐨勫畬鎴愭搷浣�
                     mainService.storeFinished();
+
+                    ///////////////////////RGV璋冨害/////////////////////////////////////
+                    // 鍏ュ嚭搴�  ===>>  RGV鍏ュ嚭搴撲綔涓氫笅鍙�
+                    mainService.rgvIoExecute();
+                    // RGV鍏ュ簱  ===>> 鏍规嵁RGV瀹屾垚淇″彿,鎵ц瀵瑰伐浣滄。鐨勫畬鎴愭搷浣�
+                    mainService.rgvFinished();
+                    // 鍏ュ嚭搴�  ===>>  RGV鍑哄簱绔欏埌绯荤粺鍏ュ嚭搴撶珯
+                    mainService.rgvDestStnToCrnStn();
+//                    // 鍑哄簱  ===>>  RGV鍑哄簱绔欏埌绯荤粺鍑哄簱绔�
+//                    mainService.rgvOutDStnToOutStn();
+                    //////////////////////////////////////////////////////////////////
+
                     // 鍫嗗灈鏈哄紓甯镐俊鎭褰�
                     mainService.recCrnErr();
                     // 鍏ュ簱  ===>> 绌烘爤鏉垮垵濮嬪寲鍏ュ簱,鍙夎溅鍏ュ簱绔欐斁璐�
diff --git a/src/main/java/com/zy/core/enums/RgvStatusType.java b/src/main/java/com/zy/core/enums/RgvStatusType.java
index 3126ba6..52a3179 100644
--- a/src/main/java/com/zy/core/enums/RgvStatusType.java
+++ b/src/main/java/com/zy/core/enums/RgvStatusType.java
@@ -8,7 +8,8 @@
     SOS(2, "鎶ヨ"),
     FETCHING(11, "鍙栬揣涓�"),
     PUTTING(12, "鏀捐揣涓�"),
-    WAITING(10, "浠诲姟瀹屾垚绛夊緟WCS纭"),
+    WAITING(90, "浠诲姟瀹屾垚绛夊緟WCS纭"),
+    FETCHWAITING(91, "鍙栬揣浠诲姟瀹屾垚绛夊緟WCS纭"),
     ;
 
     public Integer id;
diff --git a/src/main/java/com/zy/core/model/RgvSlave.java b/src/main/java/com/zy/core/model/RgvSlave.java
index 6f182af..36ff666 100644
--- a/src/main/java/com/zy/core/model/RgvSlave.java
+++ b/src/main/java/com/zy/core/model/RgvSlave.java
@@ -22,11 +22,14 @@
 
     private Boolean demo;
 
-    // 鍫嗗灈鏈哄叆搴撶珯鐐�
-    private List<RgvStn> rgvInStn = new ArrayList<>();
+    // RGV鍏ュ簱婧愮珯鐐�
+    private List<RgvStn> rgvInSStn = new ArrayList<>();
 
-    // 鍫嗗灈鏈哄嚭搴撶珯鐐�
-    private List<RgvStn> rgvOutStn = new ArrayList<>();
+    // RGV鍑哄簱婧愮珯鐐�
+    private List<RgvStn> rgvOutSStn = new ArrayList<>();
+
+    // RGV鍑哄簱鐩爣绔欑偣
+    private List<RgvStn> rgvDestStn = new ArrayList<>();
 
     @Data
     public static class RgvStn {
diff --git a/src/main/java/com/zy/core/thread/RgvThread.java b/src/main/java/com/zy/core/thread/RgvThread.java
index db19743..db8bd9c 100644
--- a/src/main/java/com/zy/core/thread/RgvThread.java
+++ b/src/main/java/com/zy/core/thread/RgvThread.java
@@ -67,9 +67,17 @@
                     case 1:
                         readStatus();
                         break;
-                    // 鍐欏叆鏁版嵁
+                    // 宸ヤ綅1銆�2鍐欏叆鏁版嵁
                     case 2:
                         write((RgvCommand) task.getData());
+                        break;
+                    //宸ヤ綅1鍐欏叆鏁版嵁
+                    case 4:
+                        write1((RgvCommand) task.getData());
+                        break;
+                    //宸ヤ綅2鍐欏叆鏁版嵁
+                    case 5:
+                        write2((RgvCommand) task.getData());
                         break;
                     // 澶嶄綅
                     case 3:
@@ -180,7 +188,8 @@
                 OutputQueue.RGV.offer(MessageFormat.format("銆恵0}銆慬id:{1}] <<<<< 瀹炴椂鏁版嵁鏇存柊鎴愬姛",DateUtils.convert(new Date()), slave.getId()));
 
                 // 宸ヤ綅1澶嶄綅淇″彿
-                if (rgvProtocol.getStatusType1().equals(RgvStatusType.WAITING)) {
+                if (rgvProtocol.getStatusType1().equals(RgvStatusType.WAITING)
+                        || rgvProtocol.getStatusType1().equals(RgvStatusType.FETCHWAITING)) {
                     if (resetFlag1) {
                         RgvCommand rgvCommand = new RgvCommand();
                         rgvCommand.setAckFinish1((short)1);
@@ -191,7 +200,8 @@
                 }
 
                 // 宸ヤ綅2澶嶄綅淇″彿
-                if (rgvProtocol.getStatusType2().equals(RgvStatusType.WAITING)) {
+                if (rgvProtocol.getStatusType2().equals(RgvStatusType.WAITING)
+                        || rgvProtocol.getStatusType2().equals(RgvStatusType.FETCHWAITING)) {
                     if (resetFlag2) {
                         RgvCommand rgvCommand = new RgvCommand();
                         rgvCommand.setAckFinish2((short)1);
@@ -306,6 +316,7 @@
         array[2] = command.getTaskMode1();
         array[3] = command.getSourceStaNo1();
         array[4] = command.getDestinationStaNo1();
+        siemensNet.Write("DB100.20", command.getCommand());
 
         OperateResult result = siemensNet.Write("DB100.0", array);
 
@@ -357,15 +368,14 @@
             return false;
         }
 
-        siemensNet.Write("DB100.20", command.getCommand());
-
         command.setRgvNo(slave.getId());
-        short[] array = new short[5];
+        short[] array = new short[6];
         array[0] = command.getAckFinish2();
         array[1] = command.getTaskNo2();
         array[2] = command.getTaskMode2();
         array[3] = command.getSourceStaNo2();
         array[4] = command.getDestinationStaNo2();
+        array[5] = command.getCommand();
 
         OperateResult result = siemensNet.Write("DB100.10", array);
 
diff --git a/src/main/java/com/zy/core/thread/SiemensCrnThread.java b/src/main/java/com/zy/core/thread/SiemensCrnThread.java
index 9bc94c7..e0709ba 100644
--- a/src/main/java/com/zy/core/thread/SiemensCrnThread.java
+++ b/src/main/java/com/zy/core/thread/SiemensCrnThread.java
@@ -179,6 +179,8 @@
 
                 // 澶嶄綅淇″彿
                 if (crnProtocol.getStatusType().equals(CrnStatusType.WAITING)) {
+                    log.error("-------------------------------------------绗竴姝ャ�乕鍫嗗灈鏈哄彿锛歿}, 宸ヤ綔鍙凤細{}, 杞借揣鍙�:{}]==>> 鐘舵�佷负10锛岀瓑寰呯‘璁わ紒锛�",
+                            slave.getId(),crnProtocol.getTaskNo(), crnProtocol.getLoaded()==1 ? "鏈夌墿" : "鏃犵墿");
                     if (resetFlag) {
                         if(crnProtocol.getTaskNo()==9999){
                             backHpFlag = false;
diff --git a/src/main/resources/application.yml b/src/main/resources/application.yml
index d2130f1..fb78128 100644
--- a/src/main/resources/application.yml
+++ b/src/main/resources/application.yml
@@ -150,18 +150,24 @@
     port: 502
     rack: 0
     slot: 0
-    rgvInStn[0]:
+    rgvInSStn[0]:
+      devpPlcId: ${wcs-slave.devp[0].id}
+      staNo: 100
+    rgvInSStn[1]:
       devpPlcId: ${wcs-slave.devp[0].id}
       staNo: 101
-    rgvInStn[1]:
-      devpPlcId: ${wcs-slave.devp[0].id}
-      staNo: 102
-    rgvOutStn[0]:
+    rgvOutSStn[0]:
       devpPlcId: ${wcs-slave.devp[0].id}
       staNo: 110
-    rgvOutStn[1]:
+    rgvOutSStn[1]:
       devpPlcId: ${wcs-slave.devp[0].id}
       staNo: 112
+    rgvDestStn[0]:
+      devpPlcId: ${wcs-slave.devp[0].id}
+      staNo: 102
+    rgvDestStn[1]:
+      devpPlcId: ${wcs-slave.devp[0].id}
+      staNo: 103
   # RGV绌挎杞�2
   rgv[1]:
     id: 2
diff --git a/src/main/resources/mapper/WrkMastMapper.xml b/src/main/resources/mapper/WrkMastMapper.xml
index 2715f0c..7356f6d 100644
--- a/src/main/resources/mapper/WrkMastMapper.xml
+++ b/src/main/resources/mapper/WrkMastMapper.xml
@@ -200,4 +200,35 @@
         order by io_pri desc,io_time,wrk_no asc
     </select>
 
+    <select id="selectRgvInStep2" resultMap="BaseResultMap">
+        select * from dbo.asr_wrk_mast where rgv_dsta_no=#{rgvInDStn} and wrk_sts=7 and (io_type=1 or io_type=10 or io_type=53 or io_type=54 or io_type=57) order by io_pri desc,io_time desc,wrk_no ASC
+    </select>
+
+    <select id="selectRgvInWorking" resultMap="BaseResultMap">
+        select * from dbo.asr_wrk_mast where 1=1 and wrk_sts in (6,7) and rgv_no=#{rgvNo} order by io_time,wrk_no
+    </select>
+
+    <select id="selectRgvOutStep2" resultMap="BaseResultMap">
+        select * from dbo.asr_wrk_mast where rgv_dsta_no=#{rgvOutDStn} and wrk_sts=17 and io_type > 100 order by io_pri desc,io_time desc,wrk_no ASC
+    </select>
+
+    <select id="selectRgvDestStep2" resultMap="BaseResultMap">
+        select * from dbo.asr_wrk_mast where rgv_dsta_no=#{rgvDestStn} and wrk_sts in (7,17) order by io_pri desc,io_time desc,wrk_no ASC
+    </select>
+
+    <select id="selectRgvOutStep1" resultMap="BaseResultMap">
+        select * from dbo.asr_wrk_mast
+        where rgv_no=#{rgvNo} and rgv_ssta_no in
+        <foreach item="item" collection="staNos" index="index"  separator="," open="(" close=")">
+            #{item}
+        </foreach>
+        and wrk_sts=14 and io_type>100 and online_yn='N'
+        order by io_pri desc,io_time,wrk_no asc
+    </select>
+
+    <select id="selectRgvOutWorking" resultMap="BaseResultMap">
+        select * from dbo.asr_wrk_mast where 1=1 and wrk_sts in (16,17) and rgv_no=#{rgvNo} order by io_time,wrk_no
+    </select>
+    <!--                                       RGV璋冨害鍏ュ嚭搴撶浉鍏�                                      -->
+
 </mapper>

--
Gitblit v1.9.1