From 9b8ff50b66361c4b56074b7586b2d5951ecf2091 Mon Sep 17 00:00:00 2001
From: Junjie <fallin.jie@qq.com>
Date: 星期四, 02 四月 2026 15:02:14 +0800
Subject: [PATCH] #优化运行速度
---
src/main/java/com/zy/core/utils/StationOperateProcessUtils.java | 301 +++++++++
src/main/java/com/zy/core/utils/station/StationRerouteProcessor.java | 303 +++++---
src/main/java/com/zy/core/plugin/store/StoreInTaskGenerationService.java | 28
src/main/java/com/zy/core/utils/DualCrnOperateProcessUtils.java | 155 +++-
src/main/java/com/zy/core/task/MainProcessTaskSubmitter.java | 62 +
src/main/java/com/zy/core/utils/CrnOperateProcessUtils.java | 230 ++++--
src/main/java/com/zy/core/utils/station/StationOutboundDispatchProcessor.java | 198 +++--
src/main/java/com/zy/core/task/MainProcessLane.java | 48 +
src/main/java/com/zy/core/plugin/FakeProcess.java | 278 ++++---
src/main/java/com/zy/core/plugin/GslProcess.java | 64 -
src/main/java/com/zy/core/utils/station/StationRegularDispatchProcessor.java | 310 +++++----
11 files changed, 1,319 insertions(+), 658 deletions(-)
diff --git a/src/main/java/com/zy/core/plugin/FakeProcess.java b/src/main/java/com/zy/core/plugin/FakeProcess.java
index 4d03f09..962bacd 100644
--- a/src/main/java/com/zy/core/plugin/FakeProcess.java
+++ b/src/main/java/com/zy/core/plugin/FakeProcess.java
@@ -28,7 +28,8 @@
import com.zy.core.plugin.store.StoreInTaskContext;
import com.zy.core.plugin.store.StoreInTaskGenerationService;
import com.zy.core.plugin.store.StoreInTaskPolicy;
-import com.zy.core.task.MainProcessAsyncTaskScheduler;
+import com.zy.core.task.MainProcessLane;
+import com.zy.core.task.MainProcessTaskSubmitter;
import com.zy.core.thread.CrnThread;
import com.zy.core.thread.DualCrnThread;
import com.zy.core.thread.StationThread;
@@ -47,14 +48,8 @@
@Slf4j
@Component
public class FakeProcess implements MainProcessPluginApi, StoreInTaskPolicy {
- private static final String CRN_TASK_LANE = "fake-crn";
- private static final String STATION_TASK_LANE = "fake-station";
- private static final String DUAL_CRN_TASK_LANE = "fake-dual-crn";
- private static final String GENERATE_STORE_TASK_LANE_PREFIX = "fake-generate-store-";
- private static final String ASYNC_TASK_LANE_PREFIX = "fake-async-";
private static final long MAIN_DISPATCH_INTERVAL_MS = 200L;
private static final long ASYNC_DISPATCH_INTERVAL_MS = 50L;
- private static final long TASK_SLOW_LOG_THRESHOLD_MS = 1000L;
private static final Map<Integer, Long> stationStayTimeMap = new ConcurrentHashMap<>();
private static volatile String enableFake = "N";
@@ -91,34 +86,39 @@
@Autowired
private StationCommandDispatcher stationCommandDispatcher;
@Autowired
- private MainProcessAsyncTaskScheduler mainProcessAsyncTaskScheduler;
+ private MainProcessTaskSubmitter mainProcessTaskSubmitter;
@Override
public void run() {
long startTime = System.currentTimeMillis();
refreshFakeConfig();
- // 浠跨湡鐩稿叧浠诲姟鎸夊悇鑷� lane 涓茶鎻愪氦锛屼簰涓嶉樆濉�
- submitAsyncTask("checkInStationHasTask", ASYNC_DISPATCH_INTERVAL_MS, this::checkInStationHasTask);
- submitAsyncTask("generateFakeInTask", ASYNC_DISPATCH_INTERVAL_MS, this::generateFakeInTask);
- submitAsyncTask("generateFakeOutTask", ASYNC_DISPATCH_INTERVAL_MS, this::generateFakeOutTask);
- submitAsyncTask("calcAllStationStayTime", ASYNC_DISPATCH_INTERVAL_MS, this::calcAllStationStayTime);
- submitAsyncTask("checkOutStationStayTimeOut", ASYNC_DISPATCH_INTERVAL_MS, this::checkOutStationStayTimeOut);
- submitAsyncTask("checkInStationCrnTake", ASYNC_DISPATCH_INTERVAL_MS, this::checkInStationCrnTake);
- submitStationTask("checkStationRunBlock", ASYNC_DISPATCH_INTERVAL_MS, stationOperateProcessUtils::checkStationRunBlock);
+ // 浠跨湡寮傛浠诲姟
+ submitAsyncTasks(ASYNC_DISPATCH_INTERVAL_MS);
+ // 浠跨湡杈撻�佺嚎鍫靛妫�娴�
+ stationOperateProcessUtils.submitCheckStationRunBlockTasks(MainProcessLane.FAKE_STATION_RUN_BLOCK, ASYNC_DISPATCH_INTERVAL_MS);
- // 璇锋眰鐢熸垚鍏ュ簱浠诲姟锛屾寜绔欑偣鎷嗘垚鐙珛涓茶閫氶亾锛岄伩鍏嶅崟绔欓樆濉炴暣杞壂鎻�
+ // 璇锋眰鐢熸垚鍏ュ簱浠诲姟
generateStoreWrkFile();
- // 鍫嗗灈鏈恒�佽緭閫佺嚎銆佸弻宸ヤ綅鍫嗗灈鏈轰换鍔″垎鍒繘鍏ュ悇鑷覆琛岄�氶亾閫愪釜鎵ц
- submitCrnTask("crnIoExecute", MAIN_DISPATCH_INTERVAL_MS, crnOperateUtils::crnIoExecute);
- submitCrnTask("crnIoExecuteFinish", MAIN_DISPATCH_INTERVAL_MS, this::crnIoExecuteFinish);
- submitStationTask("stationInExecute", MAIN_DISPATCH_INTERVAL_MS, stationOperateProcessUtils::stationInExecute);
- submitStationTask("crnStationOutExecute", MAIN_DISPATCH_INTERVAL_MS, stationOperateProcessUtils::crnStationOutExecute);
- submitStationTask("checkStationOutOrder", MAIN_DISPATCH_INTERVAL_MS, stationOperateProcessUtils::checkStationOutOrder);
- submitStationTask("watchCircleStation", MAIN_DISPATCH_INTERVAL_MS, stationOperateProcessUtils::watchCircleStation);
- submitDualCrnTask("dualCrnIoExecute", MAIN_DISPATCH_INTERVAL_MS, dualCrnOperateProcessUtils::dualCrnIoExecute);
- submitDualCrnTask("dualCrnIoExecuteFinish", MAIN_DISPATCH_INTERVAL_MS, dualCrnOperateProcessUtils::dualCrnIoExecuteFinish);
+ // 鎵ц鍫嗗灈鏈轰换鍔�
+ crnOperateUtils.submitCrnIoTasks(MainProcessLane.FAKE_CRN_IO, MAIN_DISPATCH_INTERVAL_MS);
+ // 鍫嗗灈鏈轰换鍔℃墽琛屽畬鎴�
+ submitCrnIoExecuteFinishTasks(MAIN_DISPATCH_INTERVAL_MS);
+ // 鎵ц杈撻�佺珯鐐瑰叆搴撲换鍔�
+ stationOperateProcessUtils.submitStationInTasks(MainProcessLane.FAKE_STATION_IN, MAIN_DISPATCH_INTERVAL_MS);
+ // 妫�娴嬪叆搴撲换鍔℃槸鍚﹀凡缁忓埌杈剧洰鏍囩珯鍙�
+ stationOperateProcessUtils.submitInboundStationArrivalTasks(MAIN_DISPATCH_INTERVAL_MS);
+ // 杈撻�佺嚎鎵ц鍫嗗灈鏈哄嚭搴撳悗鐨勭珯鍙版祦杞�
+ stationOperateProcessUtils.submitCrnStationOutTasks(MainProcessLane.FAKE_STATION_OUT, MAIN_DISPATCH_INTERVAL_MS);
+ // 妫�娴嬪苟澶勭悊鍑哄簱鎺掑簭
+ stationOperateProcessUtils.submitCheckStationOutOrderTasks(MainProcessLane.FAKE_STATION_OUT_ORDER, MAIN_DISPATCH_INTERVAL_MS);
+ // 鐩戞帶杈撻�佺嚎缁曞湀绔欑偣
+ stationOperateProcessUtils.submitWatchCircleStationTasks(MainProcessLane.FAKE_STATION_WATCH_CIRCLE, MAIN_DISPATCH_INTERVAL_MS);
+ // 鎵ц鍙屽伐浣嶅爢鍨涙満浠诲姟
+ dualCrnOperateProcessUtils.submitDualCrnIoTasks(MainProcessLane.FAKE_DUAL_CRN_IO, MAIN_DISPATCH_INTERVAL_MS);
+ // 鍙屽伐浣嶅爢鍨涙満浠诲姟鎵ц瀹屾垚
+ dualCrnOperateProcessUtils.submitDualCrnIoExecuteFinishTasks(MainProcessLane.FAKE_DUAL_CRN_IO_FINISH, MAIN_DISPATCH_INTERVAL_MS);
News.info("[WCS Debug] 涓荤嚎绋婻un鎵ц瀹屾垚,鑰楁椂:{}ms", System.currentTimeMillis() - startTime);
}
@@ -148,20 +148,40 @@
}
}
- private void submitCrnTask(String taskName, long minIntervalMs, Runnable task) {
- submitProcessTask(CRN_TASK_LANE, taskName, minIntervalMs, task);
- }
-
- private void submitStationTask(String taskName, long minIntervalMs, Runnable task) {
- submitProcessTask(STATION_TASK_LANE, taskName, minIntervalMs, task);
- }
-
- private void submitDualCrnTask(String taskName, long minIntervalMs, Runnable task) {
- submitProcessTask(DUAL_CRN_TASK_LANE, taskName, minIntervalMs, task);
+ private void submitAsyncTasks(long minIntervalMs) {
+ submitAsyncTask("checkInStationHasTask", minIntervalMs, this::checkInStationHasTask);
+ submitAsyncTask("generateFakeInTask", minIntervalMs, this::generateFakeInTask);
+ submitAsyncTask("generateFakeOutTask", minIntervalMs, this::generateFakeOutTask);
+ submitAsyncTask("calcAllStationStayTime", minIntervalMs, this::calcAllStationStayTime);
+ submitAsyncTask("checkOutStationStayTimeOut", minIntervalMs, this::checkOutStationStayTimeOut);
+ submitAsyncTask("checkInStationCrnTake", minIntervalMs, this::checkInStationCrnTake);
}
private void submitAsyncTask(String taskName, long minIntervalMs, Runnable task) {
- submitProcessTask(ASYNC_TASK_LANE_PREFIX + taskName, taskName, minIntervalMs, task);
+ mainProcessTaskSubmitter.submitKeyedSerialTask(
+ MainProcessLane.FAKE_ASYNC,
+ taskName,
+ taskName,
+ minIntervalMs,
+ task
+ );
+ }
+
+ private void submitCrnIoExecuteFinishTasks(long minIntervalMs) {
+ List<BasCrnp> basCrnps = basCrnpService.list(new QueryWrapper<>());
+ for (BasCrnp basCrnp : basCrnps) {
+ Integer crnNo = basCrnp == null ? null : basCrnp.getCrnNo();
+ if (crnNo == null) {
+ continue;
+ }
+ mainProcessTaskSubmitter.submitKeyedSerialTask(
+ MainProcessLane.FAKE_CRN_IO_FINISH,
+ crnNo,
+ "crnIoExecuteFinish",
+ minIntervalMs,
+ () -> crnIoExecuteFinish(basCrnp)
+ );
+ }
}
private void submitGenerateStoreTasks() {
@@ -173,24 +193,16 @@
if (stationId == null) {
continue;
}
- submitGenerateStoreTask(stationId, MAIN_DISPATCH_INTERVAL_MS,
- () -> storeInTaskGenerationService.generate(this, basDevp, stationObjModel));
+ storeInTaskGenerationService.submitGenerateStoreTask(
+ this,
+ basDevp,
+ stationObjModel,
+ MainProcessLane.FAKE_GENERATE_STORE,
+ MAIN_DISPATCH_INTERVAL_MS,
+ () -> storeInTaskGenerationService.generate(this, basDevp, stationObjModel)
+ );
}
}
- }
-
- private void submitGenerateStoreTask(Integer stationId, long minIntervalMs, Runnable task) {
- submitProcessTask(GENERATE_STORE_TASK_LANE_PREFIX + stationId, "generateStoreWrkFile", minIntervalMs, task);
- }
-
- private void submitProcessTask(String laneName, String taskName, long minIntervalMs, Runnable task) {
- mainProcessAsyncTaskScheduler.submit(
- laneName,
- taskName,
- minIntervalMs,
- TASK_SLOW_LOG_THRESHOLD_MS,
- task
- );
}
// 妫�娴嬪叆搴撶珯鏄惁鏈変换鍔＄敓鎴愶紝骞朵豢鐪熺敓鎴愭ā鎷熷叆搴撶珯鐐规暟鎹�
@@ -633,84 +645,90 @@
public void crnIoExecuteFinish() {
List<BasCrnp> basCrnps = basCrnpService.list(new QueryWrapper<>());
for (BasCrnp basCrnp : basCrnps) {
- CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, basCrnp.getCrnNo());
- if (crnThread == null) {
- continue;
- }
-
- CrnProtocol crnProtocol = crnThread.getStatus();
- if (crnProtocol == null) {
- continue;
- }
-
- if (crnProtocol.getMode() == CrnModeType.AUTO.id
- && crnProtocol.getTaskNo() > 0
- && crnProtocol.getStatus() == CrnStatusType.WAITING.id) {
- Object lock = redisUtil.get(RedisKeyType.CRN_IO_EXECUTE_FINISH_LIMIT.key + basCrnp.getCrnNo());
- if (lock != null) {
- continue;
- }
-
- // 鑾峰彇寰呯‘璁ゅ伐浣滄。
- WrkMast wrkMast = wrkMastService.selectByWorkNo(crnProtocol.getTaskNo());
- if (wrkMast == null) {
- News.error("鍫嗗灈鏈哄浜庣瓑寰呯‘璁や笖浠诲姟瀹屾垚鐘舵�侊紝浣嗘湭鎵惧埌宸ヤ綔妗ｃ�傚爢鍨涙満鍙�={}锛屽伐浣滃彿={}", basCrnp.getCrnNo(), crnProtocol.getTaskNo());
- continue;
- }
-
- Long updateWrkSts = null;
- if (wrkMast.getWrkSts() == WrkStsType.INBOUND_RUN.sts) {
- updateWrkSts = WrkStsType.COMPLETE_INBOUND.sts;
- } else if (wrkMast.getWrkSts() == WrkStsType.OUTBOUND_RUN.sts) {
- updateWrkSts = WrkStsType.OUTBOUND_RUN_COMPLETE.sts;
-
- // 鐢熸垚浠跨湡绔欑偣鏁版嵁
- List<StationObjModel> outStationList = basCrnp.getOutStationList$();
- if (outStationList.isEmpty()) {
- News.info("鍫嗗灈鏈�:{} 鍑哄簱绔欑偣鏈缃�", basCrnp.getCrnNo());
- continue;
- }
-
- for (StationObjModel stationObjModel : outStationList) {
- if (!stationObjModel.getStationId().equals(wrkMast.getSourceStaNo())) {
- continue;
- }
-
- StationThread stationThread = (StationThread) SlaveConnection.get(SlaveType.Devp,
- stationObjModel.getDeviceNo());
- if (stationThread == null) {
- continue;
- }
- // 鐢熸垚浠跨湡绔欑偣鏁版嵁
- StationCommand command = stationThread.getCommand(StationCommandType.WRITE_INFO, 9998,
- wrkMast.getSourceStaNo(), 0, 0);
- stationCommandDispatcher.dispatch(stationObjModel.getDeviceNo(), command, "fake-process", "crn-out-complete-write-info");
- redisUtil.set(RedisKeyType.CRN_OUT_TASK_COMPLETE_STATION_INFO.key + wrkMast.getWrkNo(), JSON.toJSONString(stationObjModel, SerializerFeature.DisableCircularReferenceDetect), 60 * 60 * 24);
- }
- } else if (wrkMast.getWrkSts() == WrkStsType.LOC_MOVE_RUN.sts) {
- updateWrkSts = WrkStsType.COMPLETE_LOC_MOVE.sts;
- } else if (wrkMast.getWrkSts() == WrkStsType.CRN_MOVE_RUN.sts) {
- updateWrkSts = WrkStsType.COMPLETE_CRN_MOVE.sts;
- } else {
- News.error("鍫嗗灈鏈哄浜庣瓑寰呯‘璁や笖浠诲姟瀹屾垚鐘舵�侊紝浣嗗伐浣滅姸鎬佸紓甯搞�傚爢鍨涙満鍙�={}锛屽伐浣滃彿={}", basCrnp.getCrnNo(), crnProtocol.getTaskNo());
- continue;
- }
-
- Date now = new Date();
- wrkMast.setWrkSts(updateWrkSts);
- wrkMast.setSystemMsg("");
- wrkMast.setIoTime(now);
- wrkMast.setModiTime(now);
- if (wrkMastService.updateById(wrkMast)) {
- wrkAnalysisService.markCraneComplete(wrkMast, now, updateWrkSts);
- CrnCommand resetCommand = crnThread.getResetCommand(crnProtocol.getTaskNo(), crnProtocol.getCrnNo());
- MessageQueue.offer(SlaveType.Crn, crnProtocol.getCrnNo(), new Task(2, resetCommand));
- News.info("鍫嗗灈鏈轰换鍔＄姸鎬佹洿鏂版垚鍔燂紝鍫嗗灈鏈哄彿={}锛屽伐浣滃彿={}", basCrnp.getCrnNo(), crnProtocol.getTaskNo());
- }
-
- redisUtil.set(RedisKeyType.CRN_IO_EXECUTE_FINISH_LIMIT.key + basCrnp.getCrnNo(), "lock", 10);
- }
+ crnIoExecuteFinish(basCrnp);
}
}
+ private void crnIoExecuteFinish(BasCrnp basCrnp) {
+ CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, basCrnp.getCrnNo());
+ if (crnThread == null) {
+ return;
+ }
+
+ CrnProtocol crnProtocol = crnThread.getStatus();
+ if (crnProtocol == null) {
+ return;
+ }
+
+ if (crnProtocol.getMode() != CrnModeType.AUTO.id
+ || crnProtocol.getTaskNo() <= 0
+ || crnProtocol.getStatus() != CrnStatusType.WAITING.id) {
+ return;
+ }
+
+ Object lock = redisUtil.get(RedisKeyType.CRN_IO_EXECUTE_FINISH_LIMIT.key + basCrnp.getCrnNo());
+ if (lock != null) {
+ return;
+ }
+
+ // 鑾峰彇寰呯‘璁ゅ伐浣滄。
+ WrkMast wrkMast = wrkMastService.selectByWorkNo(crnProtocol.getTaskNo());
+ if (wrkMast == null) {
+ News.error("鍫嗗灈鏈哄浜庣瓑寰呯‘璁や笖浠诲姟瀹屾垚鐘舵�侊紝浣嗘湭鎵惧埌宸ヤ綔妗ｃ�傚爢鍨涙満鍙�={}锛屽伐浣滃彿={}", basCrnp.getCrnNo(), crnProtocol.getTaskNo());
+ return;
+ }
+
+ Long updateWrkSts = null;
+ if (wrkMast.getWrkSts() == WrkStsType.INBOUND_RUN.sts) {
+ updateWrkSts = WrkStsType.COMPLETE_INBOUND.sts;
+ } else if (wrkMast.getWrkSts() == WrkStsType.OUTBOUND_RUN.sts) {
+ updateWrkSts = WrkStsType.OUTBOUND_RUN_COMPLETE.sts;
+
+ // 鐢熸垚浠跨湡绔欑偣鏁版嵁
+ List<StationObjModel> outStationList = basCrnp.getOutStationList$();
+ if (outStationList.isEmpty()) {
+ News.info("鍫嗗灈鏈�:{} 鍑哄簱绔欑偣鏈缃�", basCrnp.getCrnNo());
+ return;
+ }
+
+ for (StationObjModel stationObjModel : outStationList) {
+ if (!stationObjModel.getStationId().equals(wrkMast.getSourceStaNo())) {
+ continue;
+ }
+
+ StationThread stationThread = (StationThread) SlaveConnection.get(SlaveType.Devp,
+ stationObjModel.getDeviceNo());
+ if (stationThread == null) {
+ continue;
+ }
+ // 鐢熸垚浠跨湡绔欑偣鏁版嵁
+ StationCommand command = stationThread.getCommand(StationCommandType.WRITE_INFO, 9998,
+ wrkMast.getSourceStaNo(), 0, 0);
+ stationCommandDispatcher.dispatch(stationObjModel.getDeviceNo(), command, "fake-process", "crn-out-complete-write-info");
+ redisUtil.set(RedisKeyType.CRN_OUT_TASK_COMPLETE_STATION_INFO.key + wrkMast.getWrkNo(), JSON.toJSONString(stationObjModel, SerializerFeature.DisableCircularReferenceDetect), 60 * 60 * 24);
+ }
+ } else if (wrkMast.getWrkSts() == WrkStsType.LOC_MOVE_RUN.sts) {
+ updateWrkSts = WrkStsType.COMPLETE_LOC_MOVE.sts;
+ } else if (wrkMast.getWrkSts() == WrkStsType.CRN_MOVE_RUN.sts) {
+ updateWrkSts = WrkStsType.COMPLETE_CRN_MOVE.sts;
+ } else {
+ News.error("鍫嗗灈鏈哄浜庣瓑寰呯‘璁や笖浠诲姟瀹屾垚鐘舵�侊紝浣嗗伐浣滅姸鎬佸紓甯搞�傚爢鍨涙満鍙�={}锛屽伐浣滃彿={}", basCrnp.getCrnNo(), crnProtocol.getTaskNo());
+ return;
+ }
+
+ Date now = new Date();
+ wrkMast.setWrkSts(updateWrkSts);
+ wrkMast.setSystemMsg("");
+ wrkMast.setIoTime(now);
+ wrkMast.setModiTime(now);
+ if (wrkMastService.updateById(wrkMast)) {
+ wrkAnalysisService.markCraneComplete(wrkMast, now, updateWrkSts);
+ CrnCommand resetCommand = crnThread.getResetCommand(crnProtocol.getTaskNo(), crnProtocol.getCrnNo());
+ MessageQueue.offer(SlaveType.Crn, crnProtocol.getCrnNo(), new Task(2, resetCommand));
+ News.info("鍫嗗灈鏈轰换鍔＄姸鎬佹洿鏂版垚鍔燂紝鍫嗗灈鏈哄彿={}锛屽伐浣滃彿={}", basCrnp.getCrnNo(), crnProtocol.getTaskNo());
+ }
+
+ redisUtil.set(RedisKeyType.CRN_IO_EXECUTE_FINISH_LIMIT.key + basCrnp.getCrnNo(), "lock", 10);
+ }
+
}
diff --git a/src/main/java/com/zy/core/plugin/GslProcess.java b/src/main/java/com/zy/core/plugin/GslProcess.java
index ac2dbf7..ba7b541 100644
--- a/src/main/java/com/zy/core/plugin/GslProcess.java
+++ b/src/main/java/com/zy/core/plugin/GslProcess.java
@@ -23,7 +23,6 @@
import com.zy.core.plugin.store.StoreInTaskContext;
import com.zy.core.plugin.store.StoreInTaskGenerationService;
import com.zy.core.plugin.store.StoreInTaskPolicy;
-import com.zy.core.task.MainProcessAsyncTaskScheduler;
import com.zy.core.thread.StationThread;
import com.zy.core.utils.CrnOperateProcessUtils;
import com.zy.core.utils.StationOperateProcessUtils;
@@ -37,12 +36,8 @@
@Slf4j
@Component
public class GslProcess implements MainProcessPluginApi, StoreInTaskPolicy {
- private static final String CRN_TASK_LANE = "crn";
- private static final String STATION_TASK_LANE = "station";
- private static final String GENERATE_STORE_TASK_LANE_PREFIX = "generate-store-";
private static final long DISPATCH_INTERVAL_MS = 200L;
private static final long MAINTENANCE_INTERVAL_MS = 500L;
- private static final long TASK_SLOW_LOG_THRESHOLD_MS = 1000L;
@Autowired
private CrnOperateProcessUtils crnOperateUtils;
@@ -58,8 +53,6 @@
private StoreInTaskGenerationService storeInTaskGenerationService;
@Autowired
private StationCommandDispatcher stationCommandDispatcher;
- @Autowired
- private MainProcessAsyncTaskScheduler mainProcessAsyncTaskScheduler;
@Override
public void run() {
@@ -68,29 +61,28 @@
//璇锋眰鐢熸垚鍏ュ簱浠诲姟锛屼繚鐣欐寜绔欑偣 lane 涓茶鎻愪氦
generateStoreWrkFile();
- //鍫嗗灈鏈轰笌杈撻�佺珯鐐归兘鎸夊崟涓换鍔℃彁浜ゅ埌鍚勮嚜涓茶閫氶亾锛岄�愪釜鎵ц
- // 鍫嗗灈鏈烘墽琛屽叆鍑哄簱涓绘祦绋�
- submitCrnTask("crnIoExecute", DISPATCH_INTERVAL_MS, crnOperateUtils::crnIoExecute);
- // 鍫嗗灈鏈烘敹灏惧苟鎺ㄨ繘鍚庣画鐘舵��
- submitCrnTask("crnIoExecuteFinish", DISPATCH_INTERVAL_MS, crnOperateUtils::crnIoExecuteFinish);
- // 杈撻�佺嚎鎵ц鍏ュ簱浠诲姟涓嬪彂
- submitStationTask("stationInExecute", DISPATCH_INTERVAL_MS, stationOperateProcessUtils::stationInExecute);
+ // 鎵ц鍫嗗灈鏈轰换鍔�
+ crnOperateUtils.submitCrnIoTasks(DISPATCH_INTERVAL_MS);
+ // 鍫嗗灈鏈轰换鍔℃墽琛屽畬鎴�
+ crnOperateUtils.submitCrnIoExecuteFinishTasks(DISPATCH_INTERVAL_MS);
+ // 鎵ц杈撻�佺珯鐐瑰叆搴撲换鍔�
+ stationOperateProcessUtils.submitStationInTasks(DISPATCH_INTERVAL_MS);
+ // 妫�娴嬪叆搴撲换鍔℃槸鍚﹀凡缁忓埌杈剧洰鏍囩珯鍙�
+ stationOperateProcessUtils.submitInboundStationArrivalTasks(DISPATCH_INTERVAL_MS);
// 杈撻�佺嚎鎵ц鍫嗗灈鏈哄嚭搴撳悗鐨勭珯鍙版祦杞�
- submitStationTask("crnStationOutExecute", DISPATCH_INTERVAL_MS, stationOperateProcessUtils::crnStationOutExecute);
- // 楂橀妫�娴嬪嚭搴撲换鍔℃槸鍚﹀凡缁忓埌杈剧洰鏍囩珯鍙�
- submitStationTask("stationOutExecuteFinish", DISPATCH_INTERVAL_MS, stationOperateProcessUtils::stationOutExecuteFinish);
- // 楂橀妫�娴嬪叆搴撲换鍔℃槸鍚﹀凡缁忓埌杈剧洰鏍囩珯鍙�
- submitStationTask("scanInboundStationArrival", DISPATCH_INTERVAL_MS, stationOperateProcessUtils::scanInboundStationArrival);
+ stationOperateProcessUtils.submitCrnStationOutTasks(DISPATCH_INTERVAL_MS);
+ // 妫�娴嬪嚭搴撲换鍔℃槸鍚﹀凡缁忓埌杈剧洰鏍囩珯鍙�
+ stationOperateProcessUtils.submitStationOutExecuteFinishTasks(DISPATCH_INTERVAL_MS);
// 妫�娴嬬珯鍙拌繍琛屽畬鎴愬悗鐨勪换鍔¤浆瀹屾垚
- submitStationTask("checkTaskToComplete", DISPATCH_INTERVAL_MS, stationOperateProcessUtils::checkTaskToComplete);
+ stationOperateProcessUtils.submitCheckTaskToCompleteTasks(DISPATCH_INTERVAL_MS);
// 妫�娴嬪苟澶勭悊鍑哄簱鎺掑簭
- submitStationTask("checkStationOutOrder", MAINTENANCE_INTERVAL_MS, stationOperateProcessUtils::checkStationOutOrder);
+ stationOperateProcessUtils.submitCheckStationOutOrderTasks(MAINTENANCE_INTERVAL_MS);
// 鐩戞帶杈撻�佺嚎缁曞湀绔欑偣
- submitStationTask("watchCircleStation", MAINTENANCE_INTERVAL_MS, stationOperateProcessUtils::watchCircleStation);
+ stationOperateProcessUtils.submitWatchCircleStationTasks(MAINTENANCE_INTERVAL_MS);
// 妫�娴嬭緭閫佺嚎杩愯鍫靛
- submitStationTask("checkStationRunBlock", MAINTENANCE_INTERVAL_MS, stationOperateProcessUtils::checkStationRunBlock);
+ stationOperateProcessUtils.submitCheckStationRunBlockTasks(MAINTENANCE_INTERVAL_MS);
// 妫�娴嬬珯鍙扮┖闂茶秴鏃跺悗鐨勬仮澶嶅鐞�
- submitStationTask("checkStationIdleRecover", MAINTENANCE_INTERVAL_MS, stationOperateProcessUtils::checkStationIdleRecover);
+ stationOperateProcessUtils.submitCheckStationIdleRecoverTasks(MAINTENANCE_INTERVAL_MS);
}
@Override
@@ -178,10 +170,6 @@
}
}
- private void submitStationTask(String taskName, long minIntervalMs, Runnable task) {
- submitProcessTask(STATION_TASK_LANE, taskName, minIntervalMs, task);
- }
-
private void generateStoreWrkFile() {
List<BasDevp> basDevps = basDevpService.list(new QueryWrapper<>());
for (BasDevp basDevp : basDevps) {
@@ -207,7 +195,7 @@
if (!canRequestStoreIn(stationMap.get(stationId))) {
continue;
}
- submitGenerateStoreTask(stationId, DISPATCH_INTERVAL_MS,
+ storeInTaskGenerationService.submitGenerateStoreTask(this, basDevp, stationObjModel, DISPATCH_INTERVAL_MS,
() -> storeInTaskGenerationService.generate(this, basDevp, stationObjModel));
}
}
@@ -220,24 +208,6 @@
&& stationProtocol.isInEnable()
&& stationProtocol.getTaskNo() > 0
&& !Cools.isEmpty(stationProtocol.getBarcode());
- }
-
- private void submitGenerateStoreTask(Integer stationId, long minIntervalMs, Runnable task) {
- submitProcessTask(GENERATE_STORE_TASK_LANE_PREFIX + stationId, "generateStoreWrkFile", minIntervalMs, task);
- }
-
- private void submitCrnTask(String taskName, long minIntervalMs, Runnable task) {
- submitProcessTask(CRN_TASK_LANE, taskName, minIntervalMs, task);
- }
-
- private void submitProcessTask(String laneName, String taskName, long minIntervalMs, Runnable task) {
- mainProcessAsyncTaskScheduler.submit(
- laneName,
- taskName,
- minIntervalMs,
- TASK_SLOW_LOG_THRESHOLD_MS,
- task
- );
}
}
diff --git a/src/main/java/com/zy/core/plugin/store/StoreInTaskGenerationService.java b/src/main/java/com/zy/core/plugin/store/StoreInTaskGenerationService.java
index 9ca0352..32116ca 100644
--- a/src/main/java/com/zy/core/plugin/store/StoreInTaskGenerationService.java
+++ b/src/main/java/com/zy/core/plugin/store/StoreInTaskGenerationService.java
@@ -18,6 +18,8 @@
import com.zy.core.enums.SlaveType;
import com.zy.core.model.StationObjModel;
import com.zy.core.model.protocol.StationProtocol;
+import com.zy.core.task.MainProcessLane;
+import com.zy.core.task.MainProcessTaskSubmitter;
import com.zy.core.thread.StationThread;
import com.zy.core.utils.StationOperateProcessUtils;
import com.zy.core.utils.WmsOperateUtils;
@@ -44,6 +46,8 @@
private WmsOperateUtils wmsOperateUtils;
@Autowired
private CommonService commonService;
+ @Autowired
+ private MainProcessTaskSubmitter mainProcessTaskSubmitter;
/**
* 淇濈暀褰撳墠鎸夌珯鐐� lane 骞跺彂鐨勮兘鍔涳紝鍚屾椂鐢ㄤ竴涓畝鍗曡鏁伴伩鍏嶅苟鍙戠敓鎴愭妸绔欑偣浠诲姟鏁伴《绌夸笂闄愩��
@@ -97,6 +101,30 @@
}
}
+ public void submitGenerateStoreTask(StoreInTaskPolicy policy,
+ BasDevp basDevp,
+ StationObjModel stationObjModel,
+ long minIntervalMs,
+ Runnable task) {
+ submitGenerateStoreTask(policy, basDevp, stationObjModel, MainProcessLane.GENERATE_STORE, minIntervalMs, task);
+ }
+
+ public void submitGenerateStoreTask(StoreInTaskPolicy policy,
+ BasDevp basDevp,
+ StationObjModel stationObjModel,
+ MainProcessLane lane,
+ long minIntervalMs,
+ Runnable task) {
+ Integer stationId = stationObjModel == null ? null : stationObjModel.getStationId();
+ mainProcessTaskSubmitter.submitKeyedSerialTask(
+ lane,
+ stationId,
+ "generateStoreWrkFile",
+ minIntervalMs,
+ task
+ );
+ }
+
private void generateByStation(StoreInTaskPolicy policy, BasDevp basDevp, StationObjModel stationObjModel,
HashMap<String, String> systemConfigMap) {
StoreInTaskContext context = buildContext(basDevp, stationObjModel);
diff --git a/src/main/java/com/zy/core/task/MainProcessLane.java b/src/main/java/com/zy/core/task/MainProcessLane.java
new file mode 100644
index 0000000..746bdab
--- /dev/null
+++ b/src/main/java/com/zy/core/task/MainProcessLane.java
@@ -0,0 +1,48 @@
+package com.zy.core.task;
+
+public enum MainProcessLane {
+ CRN("crn"),
+ CRN_IO("crn-io-"),
+ CRN_IO_FINISH("crn-io-finish-"),
+ DUAL_CRN_IO("dual-crn-io-"),
+ DUAL_CRN_IO_FINISH("dual-crn-io-finish-"),
+ STATION("station"),
+ STATION_IN("station-in-"),
+ STATION_OUT("station-out-"),
+ STATION_OUT_FINISH("station-out-finish-"),
+ STATION_IN_ARRIVAL("station-in-arrival-"),
+ STATION_COMPLETE("station-complete-"),
+ STATION_OUT_ORDER("station-out-order-"),
+ STATION_WATCH_CIRCLE("station-watch-circle-"),
+ STATION_RUN_BLOCK("station-run-block-"),
+ STATION_IDLE_RECOVER("station-idle-recover-"),
+ GENERATE_STORE("generate-store-"),
+ FAKE_CRN_IO("fake-crn-io-"),
+ FAKE_CRN_IO_FINISH("fake-crn-io-finish-"),
+ FAKE_STATION_IN("fake-station-in-"),
+ FAKE_STATION_OUT("fake-station-out-"),
+ FAKE_STATION_OUT_ORDER("fake-station-out-order-"),
+ FAKE_STATION_WATCH_CIRCLE("fake-station-watch-circle-"),
+ FAKE_STATION_RUN_BLOCK("fake-station-run-block-"),
+ FAKE_DUAL_CRN_IO("fake-dual-crn-io-"),
+ FAKE_DUAL_CRN_IO_FINISH("fake-dual-crn-io-finish-"),
+ FAKE_GENERATE_STORE("fake-generate-store-"),
+ FAKE_ASYNC("fake-async-");
+
+ private final String laneName;
+
+ MainProcessLane(String laneName) {
+ this.laneName = laneName;
+ }
+
+ public String laneName() {
+ return laneName;
+ }
+
+ public String keyedLaneName(Object laneKey) {
+ if (laneKey == null) {
+ return null;
+ }
+ return laneName + laneKey;
+ }
+}
diff --git a/src/main/java/com/zy/core/task/MainProcessTaskSubmitter.java b/src/main/java/com/zy/core/task/MainProcessTaskSubmitter.java
new file mode 100644
index 0000000..81333a8
--- /dev/null
+++ b/src/main/java/com/zy/core/task/MainProcessTaskSubmitter.java
@@ -0,0 +1,62 @@
+package com.zy.core.task;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Component;
+
+@Component
+public class MainProcessTaskSubmitter {
+
+ private static final long DEFAULT_SLOW_LOG_THRESHOLD_MS = 1000L;
+
+ @Autowired
+ private MainProcessAsyncTaskScheduler mainProcessAsyncTaskScheduler;
+
+ public boolean submitSerialTask(String laneName,
+ String taskName,
+ long minIntervalMs,
+ Runnable task) {
+ return mainProcessAsyncTaskScheduler.submit(
+ laneName,
+ taskName,
+ minIntervalMs,
+ DEFAULT_SLOW_LOG_THRESHOLD_MS,
+ task
+ );
+ }
+
+ public boolean submitSerialTask(MainProcessLane lane,
+ String taskName,
+ long minIntervalMs,
+ Runnable task) {
+ if (lane == null) {
+ return false;
+ }
+ return submitSerialTask(lane.laneName(), taskName, minIntervalMs, task);
+ }
+
+ public boolean submitKeyedSerialTask(String lanePrefix,
+ Object laneKey,
+ String taskName,
+ long minIntervalMs,
+ Runnable task) {
+ if (laneKey == null) {
+ return false;
+ }
+ return submitSerialTask(lanePrefix + laneKey, taskName, minIntervalMs, task);
+ }
+
+ public boolean submitKeyedSerialTask(MainProcessLane lane,
+ Object laneKey,
+ String taskName,
+ long minIntervalMs,
+ Runnable task) {
+ if (lane == null) {
+ return false;
+ }
+ String laneName = lane.keyedLaneName(laneKey);
+ if (laneName == null) {
+ return false;
+ }
+ return submitSerialTask(laneName, taskName, minIntervalMs, task);
+ }
+}
diff --git a/src/main/java/com/zy/core/utils/CrnOperateProcessUtils.java b/src/main/java/com/zy/core/utils/CrnOperateProcessUtils.java
index 614f005..787f8c0 100644
--- a/src/main/java/com/zy/core/utils/CrnOperateProcessUtils.java
+++ b/src/main/java/com/zy/core/utils/CrnOperateProcessUtils.java
@@ -31,6 +31,8 @@
import com.zy.core.model.command.CrnCommand;
import com.zy.core.model.protocol.CrnProtocol;
import com.zy.core.model.protocol.StationProtocol;
+import com.zy.core.task.MainProcessLane;
+import com.zy.core.task.MainProcessTaskSubmitter;
import com.zy.core.thread.CrnThread;
import com.zy.core.thread.StationThread;
import org.springframework.beans.factory.annotation.Autowired;
@@ -69,30 +71,40 @@
private StationOperateProcessUtils stationOperateProcessUtils;
@Autowired
private WrkAnalysisService wrkAnalysisService;
+ @Autowired
+ private MainProcessTaskSubmitter mainProcessTaskSubmitter;
private static final String CRN_OUT_REQUIRE_STATION_OUT_ENABLE_CONFIG = "crnOutRequireStationOutEnable";
public synchronized void crnIoExecute() {
+ Set<Integer> crnMoveBlockedCrnNos = executeCrnMoveTask();
+ List<BasCrnp> basCrnps = basCrnpService.list(new QueryWrapper<>());
+ for (BasCrnp basCrnp : basCrnps) {
+ crnIoExecute(basCrnp, crnMoveBlockedCrnNos);
+ }
+ }
+
+ public void crnIoExecute(BasCrnp basCrnp, Set<Integer> crnMoveBlockedCrnNos) {
+ if (basCrnp == null || basCrnp.getCrnNo() == null) {
+ return;
+ }
Object systemConfigMapObj = redisUtil.get(RedisKeyType.SYSTEM_CONFIG_MAP.key);
if (systemConfigMapObj != null) {
HashMap<String, String> systemConfigMap = (HashMap<String, String>) systemConfigMapObj;
if (systemConfigMap.get("crnRunMethod").equals("solver")) {
- plannerExecute();
+ plannerExecute(basCrnp, crnMoveBlockedCrnNos);
}else {
- crnIoExecuteNormal();
+ crnIoExecuteNormal(basCrnp, crnMoveBlockedCrnNos);
}
}
}
//鍏ュ嚭搴� ===>> 鍫嗗灈鏈哄叆鍑哄簱浣滀笟涓嬪彂
- public synchronized void crnIoExecuteNormal() {
- Set<Integer> crnMoveBlockedCrnNos = executeCrnMoveTask();
-
- List<BasCrnp> basCrnps = basCrnpService.list(new QueryWrapper<>());
+ private void crnIoExecuteNormal(BasCrnp currentCrn, Set<Integer> crnMoveBlockedCrnNos) {
Map<Integer, BasCrnp> dispatchCrnMap = new HashMap<>();
Map<Integer, CrnThread> dispatchThreadMap = new HashMap<>();
Map<Integer, CrnProtocol> dispatchProtocolMap = new HashMap<>();
- for (BasCrnp basCrnp : basCrnps) {
+ for (BasCrnp basCrnp : java.util.Collections.singletonList(currentCrn)) {
if (basCrnp == null || basCrnp.getCrnNo() == null || crnMoveBlockedCrnNos.contains(basCrnp.getCrnNo())) {
continue;
}
@@ -611,110 +623,120 @@
public synchronized void crnIoExecuteFinish() {
List<BasCrnp> basCrnps = basCrnpService.list(new QueryWrapper<>());
for (BasCrnp basCrnp : basCrnps) {
- CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, basCrnp.getCrnNo());
- if(crnThread == null){
- continue;
+ crnIoExecuteFinish(basCrnp);
+ }
+ }
+
+ public void crnIoExecuteFinish(BasCrnp basCrnp) {
+ if (basCrnp == null || basCrnp.getCrnNo() == null) {
+ return;
+ }
+ CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, basCrnp.getCrnNo());
+ if(crnThread == null){
+ return;
+ }
+
+ CrnProtocol crnProtocol = crnThread.getStatus();
+ if(crnProtocol == null){
+ return;
+ }
+
+ if (crnProtocol.getMode() == CrnModeType.AUTO.id
+ && crnProtocol.getTaskNo() > 0
+ && crnProtocol.getStatus() == CrnStatusType.WAITING.id
+ ) {
+ Object lock = redisUtil.get(RedisKeyType.CRN_IO_EXECUTE_FINISH_LIMIT.key + basCrnp.getCrnNo());
+ if(lock != null){
+ return;
}
- CrnProtocol crnProtocol = crnThread.getStatus();
- if(crnProtocol == null){
- continue;
+ WrkMast wrkMast = wrkMastService.selectByWorkNo(crnProtocol.getTaskNo());
+ if (wrkMast == null) {
+ News.error("鍫嗗灈鏈哄浜庣瓑寰呯‘璁や笖浠诲姟瀹屾垚鐘舵�侊紝浣嗘湭鎵惧埌宸ヤ綔妗ｃ�傚爢鍨涙満鍙�={}锛屽伐浣滃彿={}", basCrnp.getCrnNo(), crnProtocol.getTaskNo());
+ return;
}
- if (crnProtocol.getMode() == CrnModeType.AUTO.id
- && crnProtocol.getTaskNo() > 0
- && crnProtocol.getStatus() == CrnStatusType.WAITING.id
- ) {
- Object lock = redisUtil.get(RedisKeyType.CRN_IO_EXECUTE_FINISH_LIMIT.key + basCrnp.getCrnNo());
- if(lock != null){
- continue;
+ Long updateWrkSts = null;
+ Date now = new Date();
+ if(wrkMast.getWrkSts() == WrkStsType.INBOUND_RUN.sts){
+ updateWrkSts = WrkStsType.COMPLETE_INBOUND.sts;
+ notifyUtils.notify(String.valueOf(SlaveType.Crn), crnProtocol.getCrnNo(), String.valueOf(wrkMast.getWrkNo()), wrkMast.getWmsWrkNo(), NotifyMsgType.CRN_IN_TASK_COMPLETE, null);
+ }else if(wrkMast.getWrkSts() == WrkStsType.OUTBOUND_RUN.sts){
+ updateWrkSts = WrkStsType.OUTBOUND_RUN_COMPLETE.sts;
+ notifyUtils.notify(String.valueOf(SlaveType.Crn), crnProtocol.getCrnNo(), String.valueOf(wrkMast.getWrkNo()), wrkMast.getWmsWrkNo(), NotifyMsgType.CRN_OUT_TASK_COMPLETE, null);
+
+ List<StationObjModel> outStationList = basCrnp.getOutStationList$();
+ if(outStationList.isEmpty()){
+ News.info("鍫嗗灈鏈�:{} 鍑哄簱绔欑偣鏈缃�", basCrnp.getCrnNo());
+ return;
}
- // 鑾峰彇寰呯‘璁ゅ伐浣滄。
- WrkMast wrkMast = wrkMastService.selectByWorkNo(crnProtocol.getTaskNo());
- if (wrkMast == null) {
- News.error("鍫嗗灈鏈哄浜庣瓑寰呯‘璁や笖浠诲姟瀹屾垚鐘舵�侊紝浣嗘湭鎵惧埌宸ヤ綔妗ｃ�傚爢鍨涙満鍙�={}锛屽伐浣滃彿={}", basCrnp.getCrnNo(), crnProtocol.getTaskNo());
- continue;
- }
-
- Long updateWrkSts = null;
- Date now = new Date();
- if(wrkMast.getWrkSts() == WrkStsType.INBOUND_RUN.sts){
- updateWrkSts = WrkStsType.COMPLETE_INBOUND.sts;
- notifyUtils.notify(String.valueOf(SlaveType.Crn), crnProtocol.getCrnNo(), String.valueOf(wrkMast.getWrkNo()), wrkMast.getWmsWrkNo(), NotifyMsgType.CRN_IN_TASK_COMPLETE, null);
- }else if(wrkMast.getWrkSts() == WrkStsType.OUTBOUND_RUN.sts){
- updateWrkSts = WrkStsType.OUTBOUND_RUN_COMPLETE.sts;
- notifyUtils.notify(String.valueOf(SlaveType.Crn), crnProtocol.getCrnNo(), String.valueOf(wrkMast.getWrkNo()), wrkMast.getWmsWrkNo(), NotifyMsgType.CRN_OUT_TASK_COMPLETE, null);
-
- List<StationObjModel> outStationList = basCrnp.getOutStationList$();
- if(outStationList.isEmpty()){
- News.info("鍫嗗灈鏈�:{} 鍑哄簱绔欑偣鏈缃�", basCrnp.getCrnNo());
- return;
+ StationObjModel outStationObjModel = null;
+ for (StationObjModel stationObjModel : outStationList) {
+ if (stationObjModel.getStationId().equals(wrkMast.getSourceStaNo())) {
+ outStationObjModel = stationObjModel;
+ break;
}
-
- StationObjModel outStationObjModel = null;
- for (StationObjModel stationObjModel : outStationList) {
- if (stationObjModel.getStationId().equals(wrkMast.getSourceStaNo())) {
- outStationObjModel = stationObjModel;
- break;
- }
- }
- redisUtil.set(RedisKeyType.CRN_OUT_TASK_COMPLETE_STATION_INFO.key + wrkMast.getWrkNo(), JSON.toJSONString(outStationObjModel, SerializerFeature.DisableCircularReferenceDetect), 60 * 60 * 24);
- }else if(wrkMast.getWrkSts() == WrkStsType.LOC_MOVE_RUN.sts){
- updateWrkSts = WrkStsType.COMPLETE_LOC_MOVE.sts;
- notifyUtils.notify(String.valueOf(SlaveType.Crn), crnProtocol.getCrnNo(), String.valueOf(wrkMast.getWrkNo()), wrkMast.getWmsWrkNo(), NotifyMsgType.CRN_TRANSFER_TASK_COMPLETE, null);
- }else if(wrkMast.getWrkSts() == WrkStsType.CRN_MOVE_RUN.sts){
- updateWrkSts = WrkStsType.COMPLETE_CRN_MOVE.sts;
- }else{
- News.error("鍫嗗灈鏈哄浜庣瓑寰呯‘璁や笖浠诲姟瀹屾垚鐘舵�侊紝浣嗗伐浣滅姸鎬佸紓甯搞�傚爢鍨涙満鍙�={}锛屽伐浣滃彿={}", basCrnp.getCrnNo(), crnProtocol.getTaskNo());
- continue;
}
-
- wrkMast.setWrkSts(updateWrkSts);
- wrkMast.setSystemMsg("");
- wrkMast.setIoTime(now);
- wrkMast.setModiTime(now);
- if (wrkMastService.updateById(wrkMast)) {
- wrkAnalysisService.markCraneComplete(wrkMast, now, updateWrkSts);
- CrnCommand resetCommand = crnThread.getResetCommand(crnProtocol.getTaskNo(), crnProtocol.getCrnNo());
- MessageQueue.offer(SlaveType.Crn, crnProtocol.getCrnNo(), new Task(2, resetCommand));
- News.info("鍫嗗灈鏈轰换鍔＄姸鎬佹洿鏂版垚鍔燂紝鍫嗗灈鏈哄彿={}锛屽伐浣滃彿={}", basCrnp.getCrnNo(), crnProtocol.getTaskNo());
- }
-
- redisUtil.set(RedisKeyType.CRN_IO_EXECUTE_FINISH_LIMIT.key + basCrnp.getCrnNo(), "lock",10);
+ redisUtil.set(RedisKeyType.CRN_OUT_TASK_COMPLETE_STATION_INFO.key + wrkMast.getWrkNo(), JSON.toJSONString(outStationObjModel, SerializerFeature.DisableCircularReferenceDetect), 60 * 60 * 24);
+ }else if(wrkMast.getWrkSts() == WrkStsType.LOC_MOVE_RUN.sts){
+ updateWrkSts = WrkStsType.COMPLETE_LOC_MOVE.sts;
+ notifyUtils.notify(String.valueOf(SlaveType.Crn), crnProtocol.getCrnNo(), String.valueOf(wrkMast.getWrkNo()), wrkMast.getWmsWrkNo(), NotifyMsgType.CRN_TRANSFER_TASK_COMPLETE, null);
+ }else if(wrkMast.getWrkSts() == WrkStsType.CRN_MOVE_RUN.sts){
+ updateWrkSts = WrkStsType.COMPLETE_CRN_MOVE.sts;
+ }else{
+ News.error("鍫嗗灈鏈哄浜庣瓑寰呯‘璁や笖浠诲姟瀹屾垚鐘舵�侊紝浣嗗伐浣滅姸鎬佸紓甯搞�傚爢鍨涙満鍙�={}锛屽伐浣滃彿={}", basCrnp.getCrnNo(), crnProtocol.getTaskNo());
+ return;
}
+
+ wrkMast.setWrkSts(updateWrkSts);
+ wrkMast.setSystemMsg("");
+ wrkMast.setIoTime(now);
+ wrkMast.setModiTime(now);
+ if (wrkMastService.updateById(wrkMast)) {
+ wrkAnalysisService.markCraneComplete(wrkMast, now, updateWrkSts);
+ CrnCommand resetCommand = crnThread.getResetCommand(crnProtocol.getTaskNo(), crnProtocol.getCrnNo());
+ MessageQueue.offer(SlaveType.Crn, crnProtocol.getCrnNo(), new Task(2, resetCommand));
+ News.info("鍫嗗灈鏈轰换鍔＄姸鎬佹洿鏂版垚鍔燂紝鍫嗗灈鏈哄彿={}锛屽伐浣滃彿={}", basCrnp.getCrnNo(), crnProtocol.getTaskNo());
+ }
+
+ redisUtil.set(RedisKeyType.CRN_IO_EXECUTE_FINISH_LIMIT.key + basCrnp.getCrnNo(), "lock",10);
}
}
public synchronized void plannerExecute() {
Set<Integer> crnMoveBlockedCrnNos = executeCrnMoveTask();
-
- int nowSec = (int) (System.currentTimeMillis() / 1000);
List<BasCrnp> basCrnps = basCrnpService.list(new QueryWrapper<>());
for (BasCrnp basCrnp : basCrnps) {
- if (basCrnp == null || basCrnp.getCrnNo() == null || crnMoveBlockedCrnNos.contains(basCrnp.getCrnNo())) {
- continue;
- }
+ plannerExecute(basCrnp, crnMoveBlockedCrnNos);
+ }
+ }
+
+ private void plannerExecute(BasCrnp basCrnp, Set<Integer> crnMoveBlockedCrnNos) {
+ int nowSec = (int) (System.currentTimeMillis() / 1000);
+ if (basCrnp == null || basCrnp.getCrnNo() == null || crnMoveBlockedCrnNos.contains(basCrnp.getCrnNo())) {
+ return;
+ }
String key = RedisKeyType.PLANNER_SCHEDULE.key + "CRN-" + basCrnp.getCrnNo();
List<Object> items = redisUtil.lGet(key, 0, -1);
if (items == null || items.isEmpty()) {
- continue;
+ return;
}
CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, basCrnp.getCrnNo());
if (crnThread == null) {
- continue;
+ return;
}
CrnProtocol crnProtocol = crnThread.getStatus();
if (crnProtocol == null) {
- continue;
+ return;
}
List<WrkMast> running = wrkMastService.list(new QueryWrapper<WrkMast>()
.eq("crn_no", basCrnp.getCrnNo())
.in("wrk_sts", WrkStsType.INBOUND_RUN.sts, WrkStsType.OUTBOUND_RUN.sts, WrkStsType.LOC_MOVE_RUN.sts, WrkStsType.CRN_MOVE_RUN.sts)
);
if (!running.isEmpty()) {
- continue;
+ return;
}
if (!(crnProtocol.getMode() == CrnModeType.AUTO.id
&& crnProtocol.getTaskNo() == 0
@@ -722,7 +744,7 @@
&& crnProtocol.getLoaded() == 0
&& crnProtocol.getForkPos() == 0
&& crnProtocol.getAlarm() == 0)) {
- continue;
+ return;
}
for (Object v : items) {
@@ -785,7 +807,6 @@
}
}
}
- }
}
private synchronized boolean crnExecuteMovePlanner(BasCrnp basCrnp, CrnThread crnThread, WrkMast wrkMast) {
@@ -950,6 +971,53 @@
return blockedCrnNoSet;
}
+ public Set<Integer> executeCrnMoveTaskAndGetBlockedCrnNos() {
+ return executeCrnMoveTask();
+ }
+
+ public void submitCrnIoTasks(long minIntervalMs) {
+ submitCrnIoTasks(MainProcessLane.CRN_IO, minIntervalMs);
+ }
+
+ public void submitCrnIoTasks(MainProcessLane lane, long minIntervalMs) {
+ Set<Integer> blockedCrnNos = executeCrnMoveTaskAndGetBlockedCrnNos();
+ List<BasCrnp> basCrnps = basCrnpService.list(new QueryWrapper<>());
+ for (BasCrnp basCrnp : basCrnps) {
+ Integer crnNo = basCrnp == null ? null : basCrnp.getCrnNo();
+ if (crnNo == null) {
+ continue;
+ }
+ mainProcessTaskSubmitter.submitKeyedSerialTask(
+ lane,
+ crnNo,
+ "crnIoExecute",
+ minIntervalMs,
+ () -> crnIoExecute(basCrnp, blockedCrnNos)
+ );
+ }
+ }
+
+ public void submitCrnIoExecuteFinishTasks(long minIntervalMs) {
+ submitCrnIoExecuteFinishTasks(MainProcessLane.CRN_IO_FINISH, minIntervalMs);
+ }
+
+ public void submitCrnIoExecuteFinishTasks(MainProcessLane lane, long minIntervalMs) {
+ List<BasCrnp> basCrnps = basCrnpService.list(new QueryWrapper<>());
+ for (BasCrnp basCrnp : basCrnps) {
+ Integer crnNo = basCrnp == null ? null : basCrnp.getCrnNo();
+ if (crnNo == null) {
+ continue;
+ }
+ mainProcessTaskSubmitter.submitKeyedSerialTask(
+ lane,
+ crnNo,
+ "crnIoExecuteFinish",
+ minIntervalMs,
+ () -> crnIoExecuteFinish(basCrnp)
+ );
+ }
+ }
+
//妫�娴嬫祬搴撲綅鐘舵��
public synchronized boolean checkShallowLocStatus(String locNo, Integer taskNo) {
String checkDeepLocOutTaskBlockReport = "Y";
diff --git a/src/main/java/com/zy/core/utils/DualCrnOperateProcessUtils.java b/src/main/java/com/zy/core/utils/DualCrnOperateProcessUtils.java
index 834800b..1d415b0 100644
--- a/src/main/java/com/zy/core/utils/DualCrnOperateProcessUtils.java
+++ b/src/main/java/com/zy/core/utils/DualCrnOperateProcessUtils.java
@@ -33,6 +33,8 @@
import com.zy.core.model.param.SendDualCrnCommandParam;
import com.zy.core.model.protocol.DualCrnProtocol;
import com.zy.core.model.protocol.StationProtocol;
+import com.zy.core.task.MainProcessLane;
+import com.zy.core.task.MainProcessTaskSubmitter;
import com.zy.core.thread.DualCrnThread;
import com.zy.core.thread.StationThread;
import org.springframework.beans.factory.annotation.Autowired;
@@ -72,6 +74,8 @@
private WrkAnalysisService wrkAnalysisService;
@Autowired
private StationCommandDispatcher stationCommandDispatcher;
+ @Autowired
+ private MainProcessTaskSubmitter mainProcessTaskSubmitter;
private static final String CRN_OUT_REQUIRE_STATION_OUT_ENABLE_CONFIG = "crnOutRequireStationOutEnable";
@@ -79,38 +83,42 @@
public synchronized void dualCrnIoExecute() {
List<BasDualCrnp> basDualCrnps = basDualCrnpService.list(new QueryWrapper<>());
for (BasDualCrnp basDualCrnp : basDualCrnps) {
- DualCrnThread dualCrnThread = (DualCrnThread) SlaveConnection.get(SlaveType.DualCrn, basDualCrnp.getCrnNo());
- if(dualCrnThread == null){
- continue;
- }
-
- DualCrnProtocol dualCrnProtocol = dualCrnThread.getStatus();
- if(dualCrnProtocol == null){
- continue;
- }
-
- List<WrkMast> wrkMasts = wrkMastService.list(new QueryWrapper<WrkMast>()
- .eq("dual_crn_no", basDualCrnp.getCrnNo())
- .in("wrk_sts", WrkStsType.INBOUND_RUN.sts, WrkStsType.OUTBOUND_RUN.sts, WrkStsType.LOC_MOVE_RUN.sts)
- );
- if(wrkMasts.size() >= 2){
- continue;
- }
-
- if(dualCrnProtocol.getMode() != DualCrnModeType.AUTO.id) {
- continue;
- }
-
- if(dualCrnProtocol.getAlarm() != 0) {
- continue;
- }
-
- if(dualCrnProtocol.getTaskSend() != 0 || dualCrnProtocol.getTaskSendTwo() != 0) {
- continue;
- }
-
- this.crnExecute(basDualCrnp, dualCrnThread);
+ dualCrnIoExecute(basDualCrnp);
}
+ }
+
+ public void dualCrnIoExecute(BasDualCrnp basDualCrnp) {
+ DualCrnThread dualCrnThread = (DualCrnThread) SlaveConnection.get(SlaveType.DualCrn, basDualCrnp.getCrnNo());
+ if(dualCrnThread == null){
+ return;
+ }
+
+ DualCrnProtocol dualCrnProtocol = dualCrnThread.getStatus();
+ if(dualCrnProtocol == null){
+ return;
+ }
+
+ List<WrkMast> wrkMasts = wrkMastService.list(new QueryWrapper<WrkMast>()
+ .eq("dual_crn_no", basDualCrnp.getCrnNo())
+ .in("wrk_sts", WrkStsType.INBOUND_RUN.sts, WrkStsType.OUTBOUND_RUN.sts, WrkStsType.LOC_MOVE_RUN.sts)
+ );
+ if(wrkMasts.size() >= 2){
+ return;
+ }
+
+ if(dualCrnProtocol.getMode() != DualCrnModeType.AUTO.id) {
+ return;
+ }
+
+ if(dualCrnProtocol.getAlarm() != 0) {
+ return;
+ }
+
+ if(dualCrnProtocol.getTaskSend() != 0 || dualCrnProtocol.getTaskSendTwo() != 0) {
+ return;
+ }
+
+ this.crnExecute(basDualCrnp, dualCrnThread);
}
private synchronized void crnExecute(BasDualCrnp basDualCrnp, DualCrnThread dualCrnThread) {
@@ -742,33 +750,78 @@
public synchronized void dualCrnIoExecuteFinish() {
List<BasDualCrnp> basDualCrnps = basDualCrnpService.list(new QueryWrapper<>());
for (BasDualCrnp basDualCrnp : basDualCrnps) {
- DualCrnThread dualCrnThread = (DualCrnThread) SlaveConnection.get(SlaveType.DualCrn, basDualCrnp.getCrnNo());
- if(dualCrnThread == null){
- continue;
- }
+ dualCrnIoExecuteFinish(basDualCrnp);
+ }
+ }
- DualCrnProtocol dualCrnProtocol = dualCrnThread.getStatus();
- if(dualCrnProtocol == null){
- continue;
- }
+ public void dualCrnIoExecuteFinish(BasDualCrnp basDualCrnp) {
+ DualCrnThread dualCrnThread = (DualCrnThread) SlaveConnection.get(SlaveType.DualCrn, basDualCrnp.getCrnNo());
+ if(dualCrnThread == null){
+ return;
+ }
- if(dualCrnProtocol.getMode() != DualCrnModeType.AUTO.id) {
- continue;
- }
+ DualCrnProtocol dualCrnProtocol = dualCrnThread.getStatus();
+ if(dualCrnProtocol == null){
+ return;
+ }
- if(dualCrnProtocol.getAlarm() != 0) {
- continue;
- }
+ if(dualCrnProtocol.getMode() != DualCrnModeType.AUTO.id) {
+ return;
+ }
- if((dualCrnProtocol.getTaskNo() > 0 && dualCrnProtocol.getDeviceTaskNo() > 0) && dualCrnProtocol.getTaskSend() == 0 && dualCrnProtocol.getStatus().equals(DualCrnStatusType.WAITING.id)) {
- executeFinish(basDualCrnp, dualCrnThread, dualCrnProtocol, dualCrnProtocol.getTaskNo(), 1);
- continue;
- }
+ if(dualCrnProtocol.getAlarm() != 0) {
+ return;
+ }
- if((dualCrnProtocol.getTaskNoTwo() > 0 && dualCrnProtocol.getDeviceTaskNoTwo() > 0) && dualCrnProtocol.getTaskSendTwo() == 0 && dualCrnProtocol.getStatusTwo().equals(DualCrnStatusType.WAITING.id)) {
- executeFinish(basDualCrnp, dualCrnThread, dualCrnProtocol, dualCrnProtocol.getTaskNoTwo(), 2);
+ if((dualCrnProtocol.getTaskNo() > 0 && dualCrnProtocol.getDeviceTaskNo() > 0) && dualCrnProtocol.getTaskSend() == 0 && dualCrnProtocol.getStatus().equals(DualCrnStatusType.WAITING.id)) {
+ executeFinish(basDualCrnp, dualCrnThread, dualCrnProtocol, dualCrnProtocol.getTaskNo(), 1);
+ return;
+ }
+
+ if((dualCrnProtocol.getTaskNoTwo() > 0 && dualCrnProtocol.getDeviceTaskNoTwo() > 0) && dualCrnProtocol.getTaskSendTwo() == 0 && dualCrnProtocol.getStatusTwo().equals(DualCrnStatusType.WAITING.id)) {
+ executeFinish(basDualCrnp, dualCrnThread, dualCrnProtocol, dualCrnProtocol.getTaskNoTwo(), 2);
+ }
+ }
+
+ public void submitDualCrnIoTasks(long minIntervalMs) {
+ submitDualCrnIoTasks(MainProcessLane.DUAL_CRN_IO, minIntervalMs);
+ }
+
+ public void submitDualCrnIoTasks(MainProcessLane lane, long minIntervalMs) {
+ List<BasDualCrnp> basDualCrnps = basDualCrnpService.list(new QueryWrapper<>());
+ for (BasDualCrnp basDualCrnp : basDualCrnps) {
+ Integer crnNo = basDualCrnp == null ? null : basDualCrnp.getCrnNo();
+ if (crnNo == null) {
continue;
}
+ mainProcessTaskSubmitter.submitKeyedSerialTask(
+ lane,
+ crnNo,
+ "dualCrnIoExecute",
+ minIntervalMs,
+ () -> dualCrnIoExecute(basDualCrnp)
+ );
+ }
+ }
+
+ public void submitDualCrnIoExecuteFinishTasks(long minIntervalMs) {
+ submitDualCrnIoExecuteFinishTasks(MainProcessLane.DUAL_CRN_IO_FINISH, minIntervalMs);
+ }
+
+ public void submitDualCrnIoExecuteFinishTasks(MainProcessLane lane, long minIntervalMs) {
+ List<BasDualCrnp> basDualCrnps = basDualCrnpService.list(new QueryWrapper<>());
+ for (BasDualCrnp basDualCrnp : basDualCrnps) {
+ Integer crnNo = basDualCrnp == null ? null : basDualCrnp.getCrnNo();
+ if (crnNo == null) {
+ continue;
+ }
+ mainProcessTaskSubmitter.submitKeyedSerialTask(
+ lane,
+ crnNo,
+ "dualCrnIoExecuteFinish",
+ minIntervalMs,
+ () -> dualCrnIoExecuteFinish(basDualCrnp)
+ );
}
}
diff --git a/src/main/java/com/zy/core/utils/StationOperateProcessUtils.java b/src/main/java/com/zy/core/utils/StationOperateProcessUtils.java
index 138a68a..0a9a7a3 100644
--- a/src/main/java/com/zy/core/utils/StationOperateProcessUtils.java
+++ b/src/main/java/com/zy/core/utils/StationOperateProcessUtils.java
@@ -1,8 +1,10 @@
package com.zy.core.utils;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.zy.asrs.entity.BasDevp;
import com.zy.asrs.entity.BasStation;
import com.zy.asrs.entity.WrkMast;
+import com.zy.asrs.service.BasDevpService;
import com.zy.asrs.service.BasStationService;
import com.zy.asrs.service.WrkAnalysisService;
import com.zy.asrs.service.WrkMastService;
@@ -11,7 +13,10 @@
import com.zy.core.enums.SlaveType;
import com.zy.core.enums.WrkIoType;
import com.zy.core.enums.WrkStsType;
+import com.zy.core.model.StationObjModel;
import com.zy.core.model.protocol.StationProtocol;
+import com.zy.core.task.MainProcessLane;
+import com.zy.core.task.MainProcessTaskSubmitter;
import com.zy.core.thread.StationThread;
import com.zy.core.utils.station.StationDispatchLoadSupport;
import com.zy.core.utils.station.StationOutboundDispatchProcessor;
@@ -33,6 +38,8 @@
@Autowired
private WrkMastService wrkMastService;
@Autowired
+ private BasDevpService basDevpService;
+ @Autowired
private BasStationService basStationService;
@Autowired
private WrkAnalysisService wrkAnalysisService;
@@ -44,15 +51,27 @@
private StationOutboundDispatchProcessor stationOutboundDispatchProcessor;
@Autowired
private StationRerouteProcessor stationRerouteProcessor;
+ @Autowired
+ private MainProcessTaskSubmitter mainProcessTaskSubmitter;
//鎵ц杈撻�佺珯鐐瑰叆搴撲换鍔�
public synchronized void stationInExecute() {
stationRegularDispatchProcessor.stationInExecute();
}
+ // 鎵ц鍗曚釜绔欑偣鐨勫叆搴撲换鍔′笅鍙�
+ public void stationInExecute(BasDevp basDevp, StationObjModel stationObjModel) {
+ stationRegularDispatchProcessor.stationInExecute(basDevp, stationObjModel);
+ }
+
//鎵ц鍫嗗灈鏈鸿緭閫佺珯鐐瑰嚭搴撲换鍔�
public synchronized void crnStationOutExecute() {
stationOutboundDispatchProcessor.crnStationOutExecute();
+ }
+
+ // 鎵ц鍗曚釜鍑哄簱浠诲姟瀵瑰簲鐨勮緭閫佺珯鐐逛笅鍙�
+ public void crnStationOutExecute(WrkMast wrkMast) {
+ stationOutboundDispatchProcessor.crnStationOutExecute(wrkMast);
}
//鎵ц鍙屽伐浣嶅爢鍨涙満杈撻�佺珯鐐瑰嚭搴撲换鍔�
@@ -63,6 +82,11 @@
//妫�娴嬭緭閫佺珯鐐瑰嚭搴撲换鍔℃墽琛屽畬鎴�
public synchronized void stationOutExecuteFinish() {
stationRegularDispatchProcessor.stationOutExecuteFinish();
+ }
+
+ // 妫�娴嬪崟涓嚭搴撲换鍔℃槸鍚﹀埌杈剧洰鏍囩珯鍙�
+ public void stationOutExecuteFinish(WrkMast wrkMast) {
+ stationRegularDispatchProcessor.stationOutExecuteFinish(wrkMast);
}
// 妫�娴嬪叆搴撲换鍔℃槸鍚﹀埌杈剧珯鍙板苟杞负绔欏彴杩愯瀹屾垚
@@ -100,9 +124,43 @@
}
}
+ // 妫�娴嬪崟涓叆搴撲换鍔℃槸鍚﹀埌杈剧洰鏍囩珯鍙�
+ public void scanInboundStationArrival(WrkMast wrkMast) {
+ if (wrkMast == null || wrkMast.getWrkNo() == null || wrkMast.getStaNo() == null) {
+ return;
+ }
+ BasStation basStation = basStationService.getOne(new QueryWrapper<BasStation>()
+ .eq("station_id", wrkMast.getStaNo())
+ .last("limit 1"));
+ if (basStation == null || basStation.getDeviceNo() == null) {
+ return;
+ }
+ StationThread stationThread = (StationThread) SlaveConnection.get(SlaveType.Devp, basStation.getDeviceNo());
+ if (stationThread == null) {
+ return;
+ }
+ Map<Integer, StationProtocol> statusMap = stationThread.getStatusMap();
+ StationProtocol stationProtocol = statusMap == null ? null : statusMap.get(basStation.getStationId());
+ boolean arrived = stationProtocol != null
+ && wrkMast.getWrkNo().equals(stationProtocol.getTaskNo())
+ && stationProtocol.isLoading();
+ if (!arrived && !stationThread.hasRecentArrival(basStation.getStationId(), wrkMast.getWrkNo())) {
+ return;
+ }
+ boolean updated = wrkAnalysisService.completeInboundStationRun(wrkMast, new Date());
+ if (updated) {
+ News.info("鍏ュ簱绔欑偣鍒拌揪鎵弿鍛戒腑锛屽伐浣滃彿={}锛岀洰鏍囩珯={}", wrkMast.getWrkNo(), wrkMast.getStaNo());
+ }
+ }
+
// 妫�娴嬩换鍔¤浆瀹屾垚
public synchronized void checkTaskToComplete() {
stationRegularDispatchProcessor.checkTaskToComplete();
+ }
+
+ // 妫�娴嬪崟涓嚭搴撲换鍔℃槸鍚﹀彲浠ヨ浆瀹屾垚
+ public void checkTaskToComplete(WrkMast wrkMast) {
+ stationRegularDispatchProcessor.checkTaskToComplete(wrkMast);
}
//妫�娴嬭緭閫佺珯鐐规槸鍚﹁繍琛屽牭濉�
@@ -110,9 +168,19 @@
stationRerouteProcessor.checkStationRunBlock();
}
+ // 妫�娴嬪崟涓珯鐐规槸鍚﹁繍琛屽牭濉�
+ public void checkStationRunBlock(BasDevp basDevp, Integer stationId) {
+ stationRerouteProcessor.checkStationRunBlock(basDevp, stationId);
+ }
+
//妫�娴嬭緭閫佺珯鐐逛换鍔″仠鐣欒秴鏃跺悗閲嶆柊璁＄畻璺緞
public synchronized void checkStationIdleRecover() {
stationRerouteProcessor.checkStationIdleRecover();
+ }
+
+ // 妫�娴嬪崟涓珯鐐逛换鍔″仠鐣欒秴鏃跺悗鐨勬仮澶嶅鐞�
+ public void checkStationIdleRecover(BasDevp basDevp, Integer stationId) {
+ stationRerouteProcessor.checkStationIdleRecover(basDevp, stationId);
}
//鑾峰彇杈撻�佺嚎浠诲姟鏁伴噺
@@ -138,11 +206,244 @@
stationRerouteProcessor.checkStationOutOrder();
}
+ // 妫�娴嬪崟涓珯鐐圭殑鍑哄簱鎺掑簭
+ public void checkStationOutOrder(BasDevp basDevp, StationObjModel stationObjModel) {
+ stationRerouteProcessor.checkStationOutOrder(basDevp, stationObjModel);
+ }
+
// 鐩戞帶缁曞湀绔欑偣
public synchronized void watchCircleStation() {
stationRerouteProcessor.watchCircleStation();
}
+ // 鐩戞帶鍗曚釜缁曞湀绔欑偣
+ public void watchCircleStation(BasDevp basDevp, Integer stationId) {
+ stationRerouteProcessor.watchCircleStation(basDevp, stationId);
+ }
+
+ public void submitStationInTasks(long minIntervalMs) {
+ submitStationInTasks(MainProcessLane.STATION_IN, minIntervalMs);
+ }
+
+ public void submitStationInTasks(MainProcessLane lane, long minIntervalMs) {
+ List<BasDevp> basDevps = basDevpService.list(new QueryWrapper<>());
+ for (BasDevp basDevp : basDevps) {
+ StationThread stationThread = (StationThread) SlaveConnection.get(SlaveType.Devp, basDevp.getDevpNo());
+ if (stationThread == null) {
+ continue;
+ }
+ Map<Integer, StationProtocol> stationMap = stationThread.getStatusMap();
+ if (stationMap == null || stationMap.isEmpty()) {
+ continue;
+ }
+ for (StationObjModel stationObjModel : basDevp.getBarcodeStationList$()) {
+ Integer stationId = stationObjModel == null ? null : stationObjModel.getStationId();
+ if (stationId == null || !stationMap.containsKey(stationId)) {
+ continue;
+ }
+ StationProtocol stationProtocol = stationMap.get(stationId);
+ if (stationProtocol == null
+ || !stationProtocol.isAutoing()
+ || !stationProtocol.isLoading()
+ || stationProtocol.getTaskNo() <= 0) {
+ continue;
+ }
+ mainProcessTaskSubmitter.submitKeyedSerialTask(
+ lane,
+ stationId,
+ "stationInExecute",
+ minIntervalMs,
+ () -> stationInExecute(basDevp, stationObjModel)
+ );
+ }
+ }
+ }
+
+ public void submitCrnStationOutTasks(long minIntervalMs) {
+ submitCrnStationOutTasks(MainProcessLane.STATION_OUT, minIntervalMs);
+ }
+
+ public void submitCrnStationOutTasks(MainProcessLane lane, long minIntervalMs) {
+ List<WrkMast> wrkMasts = wrkMastService.list(new QueryWrapper<WrkMast>()
+ .eq("wrk_sts", WrkStsType.OUTBOUND_RUN_COMPLETE.sts)
+ .isNotNull("crn_no"));
+ for (WrkMast wrkMast : wrkMasts) {
+ Integer laneKey = wrkMast == null ? null : wrkMast.getSourceStaNo();
+ if (laneKey == null) {
+ laneKey = wrkMast == null ? null : wrkMast.getWrkNo();
+ }
+ mainProcessTaskSubmitter.submitKeyedSerialTask(
+ lane,
+ laneKey,
+ "crnStationOutExecute",
+ minIntervalMs,
+ () -> crnStationOutExecute(wrkMast)
+ );
+ }
+ }
+
+ public void submitStationOutExecuteFinishTasks(long minIntervalMs) {
+ submitStationOutExecuteFinishTasks(MainProcessLane.STATION_OUT_FINISH, minIntervalMs);
+ }
+
+ public void submitStationOutExecuteFinishTasks(MainProcessLane lane, long minIntervalMs) {
+ List<WrkMast> wrkMasts = wrkMastService.list(new QueryWrapper<WrkMast>()
+ .eq("wrk_sts", WrkStsType.STATION_RUN.sts)
+ .isNotNull("sta_no"));
+ for (WrkMast wrkMast : wrkMasts) {
+ mainProcessTaskSubmitter.submitKeyedSerialTask(
+ lane,
+ wrkMast.getStaNo(),
+ "stationOutExecuteFinish",
+ minIntervalMs,
+ () -> stationOutExecuteFinish(wrkMast)
+ );
+ }
+ }
+
+ public void submitInboundStationArrivalTasks(long minIntervalMs) {
+ submitInboundStationArrivalTasks(MainProcessLane.STATION_IN_ARRIVAL, minIntervalMs);
+ }
+
+ public void submitInboundStationArrivalTasks(MainProcessLane lane, long minIntervalMs) {
+ List<WrkMast> wrkMasts = wrkMastService.list(new QueryWrapper<WrkMast>()
+ .eq("io_type", 1)
+ .eq("wrk_sts", WrkStsType.INBOUND_STATION_RUN.sts)
+ .isNotNull("sta_no"));
+ for (WrkMast wrkMast : wrkMasts) {
+ mainProcessTaskSubmitter.submitKeyedSerialTask(
+ lane,
+ wrkMast.getStaNo(),
+ "scanInboundStationArrival",
+ minIntervalMs,
+ () -> scanInboundStationArrival(wrkMast)
+ );
+ }
+ }
+
+ public void submitCheckTaskToCompleteTasks(long minIntervalMs) {
+ submitCheckTaskToCompleteTasks(MainProcessLane.STATION_COMPLETE, minIntervalMs);
+ }
+
+ public void submitCheckTaskToCompleteTasks(MainProcessLane lane, long minIntervalMs) {
+ List<WrkMast> wrkMasts = wrkMastService.list(new QueryWrapper<WrkMast>()
+ .eq("wrk_sts", WrkStsType.STATION_RUN_COMPLETE.sts)
+ .isNotNull("sta_no"));
+ for (WrkMast wrkMast : wrkMasts) {
+ mainProcessTaskSubmitter.submitKeyedSerialTask(
+ lane,
+ wrkMast.getStaNo(),
+ "checkTaskToComplete",
+ minIntervalMs,
+ () -> checkTaskToComplete(wrkMast)
+ );
+ }
+ }
+
+ public void submitCheckStationOutOrderTasks(long minIntervalMs) {
+ submitCheckStationOutOrderTasks(MainProcessLane.STATION_OUT_ORDER, minIntervalMs);
+ }
+
+ public void submitCheckStationOutOrderTasks(MainProcessLane lane, long minIntervalMs) {
+ List<BasDevp> basDevps = basDevpService.list(new QueryWrapper<>());
+ for (BasDevp basDevp : basDevps) {
+ for (StationObjModel stationObjModel : basDevp.getOutOrderList$()) {
+ Integer stationId = stationObjModel == null ? null : stationObjModel.getStationId();
+ if (stationId == null) {
+ continue;
+ }
+ mainProcessTaskSubmitter.submitKeyedSerialTask(
+ lane,
+ stationId,
+ "checkStationOutOrder",
+ minIntervalMs,
+ () -> checkStationOutOrder(basDevp, stationObjModel)
+ );
+ }
+ }
+ }
+
+ public void submitWatchCircleStationTasks(long minIntervalMs) {
+ submitWatchCircleStationTasks(MainProcessLane.STATION_WATCH_CIRCLE, minIntervalMs);
+ }
+
+ public void submitWatchCircleStationTasks(MainProcessLane lane, long minIntervalMs) {
+ List<BasDevp> basDevps = basDevpService.list(new QueryWrapper<>());
+ for (BasDevp basDevp : basDevps) {
+ StationThread stationThread = (StationThread) SlaveConnection.get(SlaveType.Devp, basDevp.getDevpNo());
+ if (stationThread == null) {
+ continue;
+ }
+ for (StationProtocol stationProtocol : stationThread.getStatus()) {
+ Integer stationId = stationProtocol == null ? null : stationProtocol.getStationId();
+ if (stationId == null) {
+ continue;
+ }
+ mainProcessTaskSubmitter.submitKeyedSerialTask(
+ lane,
+ stationId,
+ "watchCircleStation",
+ minIntervalMs,
+ () -> watchCircleStation(basDevp, stationId)
+ );
+ }
+ }
+ }
+
+ public void submitCheckStationRunBlockTasks(long minIntervalMs) {
+ submitCheckStationRunBlockTasks(MainProcessLane.STATION_RUN_BLOCK, minIntervalMs);
+ }
+
+ public void submitCheckStationRunBlockTasks(MainProcessLane lane, long minIntervalMs) {
+ List<BasDevp> basDevps = basDevpService.list(new QueryWrapper<>());
+ for (BasDevp basDevp : basDevps) {
+ StationThread stationThread = (StationThread) SlaveConnection.get(SlaveType.Devp, basDevp.getDevpNo());
+ if (stationThread == null) {
+ continue;
+ }
+ for (StationProtocol stationProtocol : stationThread.getStatus()) {
+ Integer stationId = stationProtocol == null ? null : stationProtocol.getStationId();
+ if (stationId == null) {
+ continue;
+ }
+ mainProcessTaskSubmitter.submitKeyedSerialTask(
+ lane,
+ stationId,
+ "checkStationRunBlock",
+ minIntervalMs,
+ () -> checkStationRunBlock(basDevp, stationId)
+ );
+ }
+ }
+ }
+
+ public void submitCheckStationIdleRecoverTasks(long minIntervalMs) {
+ submitCheckStationIdleRecoverTasks(MainProcessLane.STATION_IDLE_RECOVER, minIntervalMs);
+ }
+
+ public void submitCheckStationIdleRecoverTasks(MainProcessLane lane, long minIntervalMs) {
+ List<BasDevp> basDevps = basDevpService.list(new QueryWrapper<>());
+ for (BasDevp basDevp : basDevps) {
+ StationThread stationThread = (StationThread) SlaveConnection.get(SlaveType.Devp, basDevp.getDevpNo());
+ if (stationThread == null) {
+ continue;
+ }
+ for (StationProtocol stationProtocol : stationThread.getStatus()) {
+ Integer stationId = stationProtocol == null ? null : stationProtocol.getStationId();
+ if (stationId == null) {
+ continue;
+ }
+ mainProcessTaskSubmitter.submitKeyedSerialTask(
+ lane,
+ stationId,
+ "checkStationIdleRecover",
+ minIntervalMs,
+ () -> checkStationIdleRecover(basDevp, stationId)
+ );
+ }
+ }
+ }
+
RerouteCommandPlan buildRerouteCommandPlan(RerouteContext context,
RerouteDecision decision) {
return stationRerouteProcessor.buildRerouteCommandPlan(context, decision);
diff --git a/src/main/java/com/zy/core/utils/station/StationOutboundDispatchProcessor.java b/src/main/java/com/zy/core/utils/station/StationOutboundDispatchProcessor.java
index 644090a..b5d654e 100644
--- a/src/main/java/com/zy/core/utils/station/StationOutboundDispatchProcessor.java
+++ b/src/main/java/com/zy/core/utils/station/StationOutboundDispatchProcessor.java
@@ -53,114 +53,126 @@
public void crnStationOutExecute() {
try {
- DispatchLimitConfig baseLimitConfig =
- stationDispatchLoadSupport.getDispatchLimitConfig(null, null);
- int[] currentStationTaskCountRef = new int[]{stationDispatchLoadSupport.countCurrentStationTask()};
- LoadGuardState loadGuardState =
- stationDispatchLoadSupport.buildLoadGuardState(baseLimitConfig);
-
List<WrkMast> wrkMasts = wrkMastService.list(new QueryWrapper<WrkMast>()
.eq("wrk_sts", WrkStsType.OUTBOUND_RUN_COMPLETE.sts)
.isNotNull("crn_no"));
- List<Integer> outOrderList = stationOutboundDecisionSupport.getAllOutOrderList();
-
for (WrkMast wrkMast : wrkMasts) {
- Object infoObj = redisUtil.get(RedisKeyType.CRN_OUT_TASK_COMPLETE_STATION_INFO.key + wrkMast.getWrkNo());
- if (infoObj == null) {
- News.info("鍑哄簱浠诲姟{}鏁版嵁缂撳瓨涓嶅瓨鍦�", wrkMast.getWrkNo());
- continue;
- }
+ crnStationOutExecute(wrkMast);
+ }
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ }
- StationObjModel stationObjModel = JSON.parseObject(infoObj.toString(), StationObjModel.class);
- StationThread stationThread = (StationThread) SlaveConnection.get(SlaveType.Devp, stationObjModel.getDeviceNo());
- if (stationThread == null) {
- continue;
- }
+ public void crnStationOutExecute(WrkMast wrkMast) {
+ try {
+ if (wrkMast == null || wrkMast.getWrkNo() == null) {
+ return;
+ }
- Map<Integer, StationProtocol> stationMap = stationThread.getStatusMap();
- StationProtocol stationProtocol = stationMap.get(stationObjModel.getStationId());
- if (stationProtocol == null) {
- continue;
- }
+ Object infoObj = redisUtil.get(RedisKeyType.CRN_OUT_TASK_COMPLETE_STATION_INFO.key + wrkMast.getWrkNo());
+ if (infoObj == null) {
+ News.info("鍑哄簱浠诲姟{}鏁版嵁缂撳瓨涓嶅瓨鍦�", wrkMast.getWrkNo());
+ return;
+ }
- Object lock = redisUtil.get(RedisKeyType.STATION_OUT_EXECUTE_LIMIT.key + stationProtocol.getStationId());
- if (lock != null) {
- continue;
- }
+ StationObjModel stationObjModel = JSON.parseObject(infoObj.toString(), StationObjModel.class);
+ if (stationObjModel == null || stationObjModel.getDeviceNo() == null || stationObjModel.getStationId() == null) {
+ return;
+ }
- if (stationProtocol.isAutoing()
- && stationProtocol.isLoading()
- && stationProtocol.getTaskNo() == 0) {
- Double pathLenFactor = stationOutboundDecisionSupport.resolveOutboundPathLenFactor(wrkMast);
- OutOrderDispatchDecision dispatchDecision =
- stationOutboundDecisionSupport.resolveOutboundDispatchDecision(
- stationProtocol.getStationId(),
- wrkMast,
- outOrderList,
- pathLenFactor
- );
- Integer moveStaNo = dispatchDecision == null ? null : dispatchDecision.getTargetStationId();
- if (moveStaNo == null) {
- continue;
- }
+ StationThread stationThread = (StationThread) SlaveConnection.get(SlaveType.Devp, stationObjModel.getDeviceNo());
+ if (stationThread == null) {
+ return;
+ }
- DispatchLimitConfig limitConfig =
- stationDispatchLoadSupport.getDispatchLimitConfig(stationProtocol.getStationId(), moveStaNo);
- LoopHitResult loopHitResult =
- stationDispatchLoadSupport.findPathLoopHit(
- limitConfig,
- stationProtocol.getStationId(),
- moveStaNo,
- loadGuardState,
- wrkMast,
- pathLenFactor
- );
- if (stationDispatchLoadSupport.isDispatchBlocked(
- limitConfig,
- currentStationTaskCountRef[0],
- loadGuardState,
- loopHitResult.isThroughLoop())) {
- return;
- }
+ Map<Integer, StationProtocol> stationMap = stationThread.getStatusMap();
+ StationProtocol stationProtocol = stationMap == null ? null : stationMap.get(stationObjModel.getStationId());
+ if (stationProtocol == null) {
+ return;
+ }
- StationCommand command = stationOutboundDecisionSupport.buildOutboundMoveCommand(
- stationThread,
- wrkMast,
+ Object lock = redisUtil.get(RedisKeyType.STATION_OUT_EXECUTE_LIMIT.key + stationProtocol.getStationId());
+ if (lock != null) {
+ return;
+ }
+
+ if (!(stationProtocol.isAutoing()
+ && stationProtocol.isLoading()
+ && stationProtocol.getTaskNo() == 0)) {
+ return;
+ }
+
+ Double pathLenFactor = stationOutboundDecisionSupport.resolveOutboundPathLenFactor(wrkMast);
+ List<Integer> outOrderList = stationOutboundDecisionSupport.getAllOutOrderList();
+ OutOrderDispatchDecision dispatchDecision =
+ stationOutboundDecisionSupport.resolveOutboundDispatchDecision(
stationProtocol.getStationId(),
- moveStaNo,
+ wrkMast,
+ outOrderList,
pathLenFactor
);
- if (command == null) {
- News.taskInfo(wrkMast.getWrkNo(), "鑾峰彇杈撻�佺嚎鍛戒护澶辫触");
- continue;
- }
+ Integer moveStaNo = dispatchDecision == null ? null : dispatchDecision.getTargetStationId();
+ if (moveStaNo == null) {
+ return;
+ }
- Date now = new Date();
- wrkMast.setWrkSts(WrkStsType.STATION_RUN.sts);
- wrkMast.setSystemMsg("");
- wrkMast.setIoTime(now);
- wrkMast.setModiTime(now);
- if (wrkMastService.updateById(wrkMast)) {
- wrkAnalysisService.markOutboundStationStart(wrkMast, now);
- boolean offered = offerDevpCommandWithDedup(stationObjModel.getDeviceNo(), command, "crnStationOutExecute");
- if (offered && stationMoveCoordinator != null) {
- stationMoveCoordinator.recordDispatch(
- wrkMast.getWrkNo(),
- stationProtocol.getStationId(),
- "crnStationOutExecute",
- command,
- false
- );
- }
- News.info("杈撻�佺珯鐐瑰嚭搴撳懡浠や笅鍙戞垚鍔燂紝绔欑偣鍙�={}锛屽伐浣滃彿={}锛屽懡浠ゆ暟鎹�={}",
- stationProtocol.getStationId(), wrkMast.getWrkNo(), JSON.toJSONString(command));
- redisUtil.set(RedisKeyType.STATION_OUT_EXECUTE_LIMIT.key + stationProtocol.getStationId(), "lock", 5);
- redisUtil.del(RedisKeyType.CRN_OUT_TASK_COMPLETE_STATION_INFO.key + wrkMast.getWrkNo());
- currentStationTaskCountRef[0]++;
- loadGuardState.reserveLoopTask(loopHitResult.getLoopNo());
- stationDispatchLoadSupport.saveLoopLoadReserve(wrkMast.getWrkNo(), loopHitResult);
- }
+ DispatchLimitConfig limitConfig =
+ stationDispatchLoadSupport.getDispatchLimitConfig(stationProtocol.getStationId(), moveStaNo);
+ int currentStationTaskCount = stationDispatchLoadSupport.countCurrentStationTask();
+ LoadGuardState loadGuardState = stationDispatchLoadSupport.buildLoadGuardState(limitConfig);
+ LoopHitResult loopHitResult =
+ stationDispatchLoadSupport.findPathLoopHit(
+ limitConfig,
+ stationProtocol.getStationId(),
+ moveStaNo,
+ loadGuardState,
+ wrkMast,
+ pathLenFactor
+ );
+ if (stationDispatchLoadSupport.isDispatchBlocked(
+ limitConfig,
+ currentStationTaskCount,
+ loadGuardState,
+ loopHitResult.isThroughLoop())) {
+ return;
+ }
+
+ StationCommand command = stationOutboundDecisionSupport.buildOutboundMoveCommand(
+ stationThread,
+ wrkMast,
+ stationProtocol.getStationId(),
+ moveStaNo,
+ pathLenFactor
+ );
+ if (command == null) {
+ News.taskInfo(wrkMast.getWrkNo(), "鑾峰彇杈撻�佺嚎鍛戒护澶辫触");
+ return;
+ }
+
+ Date now = new Date();
+ wrkMast.setWrkSts(WrkStsType.STATION_RUN.sts);
+ wrkMast.setSystemMsg("");
+ wrkMast.setIoTime(now);
+ wrkMast.setModiTime(now);
+ if (wrkMastService.updateById(wrkMast)) {
+ wrkAnalysisService.markOutboundStationStart(wrkMast, now);
+ boolean offered = offerDevpCommandWithDedup(stationObjModel.getDeviceNo(), command, "crnStationOutExecute");
+ if (offered && stationMoveCoordinator != null) {
+ stationMoveCoordinator.recordDispatch(
+ wrkMast.getWrkNo(),
+ stationProtocol.getStationId(),
+ "crnStationOutExecute",
+ command,
+ false
+ );
}
+ News.info("杈撻�佺珯鐐瑰嚭搴撳懡浠や笅鍙戞垚鍔燂紝绔欑偣鍙�={}锛屽伐浣滃彿={}锛屽懡浠ゆ暟鎹�={}",
+ stationProtocol.getStationId(), wrkMast.getWrkNo(), JSON.toJSONString(command));
+ redisUtil.set(RedisKeyType.STATION_OUT_EXECUTE_LIMIT.key + stationProtocol.getStationId(), "lock", 5);
+ redisUtil.del(RedisKeyType.CRN_OUT_TASK_COMPLETE_STATION_INFO.key + wrkMast.getWrkNo());
+ loadGuardState.reserveLoopTask(loopHitResult.getLoopNo());
+ stationDispatchLoadSupport.saveLoopLoadReserve(wrkMast.getWrkNo(), loopHitResult);
}
} catch (Exception e) {
e.printStackTrace();
diff --git a/src/main/java/com/zy/core/utils/station/StationRegularDispatchProcessor.java b/src/main/java/com/zy/core/utils/station/StationRegularDispatchProcessor.java
index f55f553..e33d401 100644
--- a/src/main/java/com/zy/core/utils/station/StationRegularDispatchProcessor.java
+++ b/src/main/java/com/zy/core/utils/station/StationRegularDispatchProcessor.java
@@ -65,100 +65,11 @@
public void stationInExecute() {
try {
- DispatchLimitConfig baseLimitConfig = stationDispatchLoadSupport.getDispatchLimitConfig(null, null);
- int[] currentStationTaskCountRef = new int[]{stationDispatchLoadSupport.countCurrentStationTask()};
- LoadGuardState loadGuardState = stationDispatchLoadSupport.buildLoadGuardState(baseLimitConfig);
-
List<BasDevp> basDevps = basDevpService.list(new QueryWrapper<>());
for (BasDevp basDevp : basDevps) {
- StationThread stationThread = (StationThread) SlaveConnection.get(SlaveType.Devp, basDevp.getDevpNo());
- if (stationThread == null) {
- continue;
- }
-
- Map<Integer, StationProtocol> stationMap = stationThread.getStatusMap();
List<StationObjModel> stationList = basDevp.getBarcodeStationList$();
for (StationObjModel entity : stationList) {
- Integer stationId = entity.getStationId();
- if (!stationMap.containsKey(stationId)) {
- continue;
- }
-
- StationProtocol stationProtocol = stationMap.get(stationId);
- if (stationProtocol == null) {
- continue;
- }
-
- Object lock = redisUtil.get(RedisKeyType.STATION_IN_EXECUTE_LIMIT.key + stationId);
- if (lock != null) {
- continue;
- }
-
- if (!stationProtocol.isAutoing()
- || !stationProtocol.isLoading()
- || stationProtocol.getTaskNo() <= 0) {
- continue;
- }
-
- WrkMast wrkMast = wrkMastService.getOne(new QueryWrapper<WrkMast>().eq("barcode", stationProtocol.getBarcode()));
- if (wrkMast == null || !Objects.equals(wrkMast.getWrkSts(), WrkStsType.NEW_INBOUND.sts)) {
- continue;
- }
-
- String locNo = wrkMast.getLocNo();
- FindCrnNoResult findCrnNoResult = commonService.findCrnNoByLocNo(locNo);
- if (findCrnNoResult == null) {
- News.taskInfo(wrkMast.getWrkNo(), "{}宸ヤ綔,鏈尮閰嶅埌鍫嗗灈鏈�", wrkMast.getWrkNo());
- continue;
- }
-
- Integer targetStationId = commonService.findInStationId(findCrnNoResult, stationId);
- if (targetStationId == null) {
- News.taskInfo(wrkMast.getWrkNo(), "{}绔欑偣,鎼滅储鍏ュ簱绔欑偣澶辫触", stationId);
- continue;
- }
-
- DispatchLimitConfig limitConfig = stationDispatchLoadSupport.getDispatchLimitConfig(stationProtocol.getStationId(), targetStationId);
- LoopHitResult loopHitResult = stationDispatchLoadSupport.findPathLoopHit(
- limitConfig,
- stationProtocol.getStationId(),
- targetStationId,
- loadGuardState
- );
- if (stationDispatchLoadSupport.isDispatchBlocked(limitConfig, currentStationTaskCountRef[0], loadGuardState, loopHitResult.isThroughLoop())) {
- continue;
- }
-
- StationCommand command = stationThread.getCommand(StationCommandType.MOVE, wrkMast.getWrkNo(), stationId, targetStationId, 0);
- if (command == null) {
- News.taskInfo(wrkMast.getWrkNo(), "{}宸ヤ綔,鑾峰彇杈撻�佺嚎鍛戒护澶辫触", wrkMast.getWrkNo());
- continue;
- }
-
- Date now = new Date();
- wrkMast.setWrkSts(WrkStsType.INBOUND_STATION_RUN.sts);
- wrkMast.setSourceStaNo(stationProtocol.getStationId());
- wrkMast.setStaNo(targetStationId);
- wrkMast.setSystemMsg("");
- wrkMast.setIoTime(now);
- wrkMast.setModiTime(now);
- if (wrkMastService.updateById(wrkMast)) {
- wrkAnalysisService.markInboundStationStart(wrkMast, now);
- boolean offered = offerDevpCommandWithDedup(basDevp.getDevpNo(), command, "stationInExecute");
- if (offered && stationMoveCoordinator != null) {
- stationMoveCoordinator.recordDispatch(
- wrkMast.getWrkNo(),
- stationProtocol.getStationId(),
- "stationInExecute",
- command,
- false
- );
- }
- News.info("杈撻�佺珯鐐瑰叆搴撳懡浠や笅鍙戞垚鍔燂紝绔欑偣鍙�={}锛屽伐浣滃彿={}锛屽懡浠ゆ暟鎹�={}", stationId, wrkMast.getWrkNo(), JSON.toJSONString(command));
- redisUtil.set(RedisKeyType.STATION_IN_EXECUTE_LIMIT.key + stationId, "lock", 5);
- loadGuardState.reserveLoopTask(loopHitResult.getLoopNo());
- stationDispatchLoadSupport.saveLoopLoadReserve(wrkMast.getWrkNo(), loopHitResult);
- }
+ stationInExecute(basDevp, entity);
}
}
} catch (Exception e) {
@@ -170,36 +81,47 @@
try {
List<WrkMast> wrkMasts = wrkMastService.list(new QueryWrapper<WrkMast>().eq("wrk_sts", WrkStsType.STATION_RUN.sts));
for (WrkMast wrkMast : wrkMasts) {
- Integer wrkNo = wrkMast.getWrkNo();
- Integer targetStaNo = wrkMast.getStaNo();
- if (wrkNo == null || targetStaNo == null) {
- continue;
- }
+ stationOutExecuteFinish(wrkMast);
+ }
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ }
- boolean complete = false;
- Integer targetDeviceNo = null;
- StationThread stationThread = null;
- BasStation basStation = basStationService.getOne(new QueryWrapper<BasStation>().eq("station_id", targetStaNo));
- if (basStation != null) {
- targetDeviceNo = basStation.getDeviceNo();
- stationThread = (StationThread) SlaveConnection.get(SlaveType.Devp, basStation.getDeviceNo());
- if (stationThread != null) {
- Map<Integer, StationProtocol> statusMap = stationThread.getStatusMap();
- StationProtocol stationProtocol = statusMap == null ? null : statusMap.get(basStation.getStationId());
- boolean arrived = stationProtocol != null && wrkNo.equals(stationProtocol.getTaskNo());
- if (arrived || stationThread.hasRecentArrival(basStation.getStationId(), wrkNo)) {
- complete = true;
- if (!arrived) {
- News.info("杈撻�佺珯鐐瑰嚭搴撳埌杈惧垽瀹氫娇鐢ㄦ渶杩戝埌绔欒ˉ鍋匡紝宸ヤ綔鍙�={}锛岀洰鏍囩珯={}", wrkNo, targetStaNo);
- }
+ public void stationOutExecuteFinish(WrkMast wrkMast) {
+ try {
+ if (wrkMast == null) {
+ return;
+ }
+ Integer wrkNo = wrkMast.getWrkNo();
+ Integer targetStaNo = wrkMast.getStaNo();
+ if (wrkNo == null || targetStaNo == null) {
+ return;
+ }
+
+ boolean complete = false;
+ Integer targetDeviceNo = null;
+ StationThread stationThread = null;
+ BasStation basStation = basStationService.getOne(new QueryWrapper<BasStation>().eq("station_id", targetStaNo));
+ if (basStation != null) {
+ targetDeviceNo = basStation.getDeviceNo();
+ stationThread = (StationThread) SlaveConnection.get(SlaveType.Devp, basStation.getDeviceNo());
+ if (stationThread != null) {
+ Map<Integer, StationProtocol> statusMap = stationThread.getStatusMap();
+ StationProtocol stationProtocol = statusMap == null ? null : statusMap.get(basStation.getStationId());
+ boolean arrived = stationProtocol != null && wrkNo.equals(stationProtocol.getTaskNo());
+ if (arrived || stationThread.hasRecentArrival(basStation.getStationId(), wrkNo)) {
+ complete = true;
+ if (!arrived) {
+ News.info("杈撻�佺珯鐐瑰嚭搴撳埌杈惧垽瀹氫娇鐢ㄦ渶杩戝埌绔欒ˉ鍋匡紝宸ヤ綔鍙�={}锛岀洰鏍囩珯={}", wrkNo, targetStaNo);
}
}
}
+ }
- if (complete) {
- attemptClearTaskPath(stationThread, wrkNo);
- completeStationRunTask(wrkMast, targetDeviceNo);
- }
+ if (complete) {
+ attemptClearTaskPath(stationThread, wrkNo);
+ completeStationRunTask(wrkMast, targetDeviceNo);
}
} catch (Exception e) {
e.printStackTrace();
@@ -210,38 +132,49 @@
try {
List<WrkMast> wrkMasts = wrkMastService.list(new QueryWrapper<WrkMast>().eq("wrk_sts", WrkStsType.STATION_RUN_COMPLETE.sts));
for (WrkMast wrkMast : wrkMasts) {
- Integer wrkNo = wrkMast.getWrkNo();
- Integer targetStaNo = wrkMast.getStaNo();
+ checkTaskToComplete(wrkMast);
+ }
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ }
- Object lock = redisUtil.get(RedisKeyType.STATION_OUT_EXECUTE_COMPLETE_LIMIT.key + wrkNo);
- if (lock != null) {
- continue;
- }
+ public void checkTaskToComplete(WrkMast wrkMast) {
+ try {
+ if (wrkMast == null || wrkMast.getWrkNo() == null || wrkMast.getStaNo() == null) {
+ return;
+ }
+ Integer wrkNo = wrkMast.getWrkNo();
+ Integer targetStaNo = wrkMast.getStaNo();
- BasStation basStation = basStationService.getOne(new QueryWrapper<BasStation>().eq("station_id", targetStaNo));
- if (basStation == null) {
- continue;
- }
+ Object lock = redisUtil.get(RedisKeyType.STATION_OUT_EXECUTE_COMPLETE_LIMIT.key + wrkNo);
+ if (lock != null) {
+ return;
+ }
- StationThread stationThread = (StationThread) SlaveConnection.get(SlaveType.Devp, basStation.getDeviceNo());
- if (stationThread == null) {
- continue;
- }
+ BasStation basStation = basStationService.getOne(new QueryWrapper<BasStation>().eq("station_id", targetStaNo));
+ if (basStation == null) {
+ return;
+ }
- Map<Integer, StationProtocol> statusMap = stationThread.getStatusMap();
- StationProtocol stationProtocol = statusMap.get(basStation.getStationId());
- if (stationProtocol == null) {
- continue;
- }
+ StationThread stationThread = (StationThread) SlaveConnection.get(SlaveType.Devp, basStation.getDeviceNo());
+ if (stationThread == null) {
+ return;
+ }
- if (!Objects.equals(stationProtocol.getTaskNo(), wrkNo)) {
- if (stationMoveCoordinator != null) {
- stationMoveCoordinator.finishSession(wrkNo);
- }
- wrkMast.setWrkSts(WrkStsType.COMPLETE_OUTBOUND.sts);
- wrkMast.setIoTime(new Date());
- wrkMastService.updateById(wrkMast);
+ Map<Integer, StationProtocol> statusMap = stationThread.getStatusMap();
+ StationProtocol stationProtocol = statusMap == null ? null : statusMap.get(basStation.getStationId());
+ if (stationProtocol == null) {
+ return;
+ }
+
+ if (!Objects.equals(stationProtocol.getTaskNo(), wrkNo)) {
+ if (stationMoveCoordinator != null) {
+ stationMoveCoordinator.finishSession(wrkNo);
}
+ wrkMast.setWrkSts(WrkStsType.COMPLETE_OUTBOUND.sts);
+ wrkMast.setIoTime(new Date());
+ wrkMastService.updateById(wrkMast);
}
} catch (Exception e) {
e.printStackTrace();
@@ -285,4 +218,99 @@
StationCommandDispatchResult dispatchResult = stationCommandDispatcher.dispatch(deviceNo, command, "station-operate-process", scene);
return dispatchResult.isAccepted();
}
+
+ public void stationInExecute(BasDevp basDevp, StationObjModel entity) {
+ if (basDevp == null || basDevp.getDevpNo() == null || entity == null || entity.getStationId() == null) {
+ return;
+ }
+
+ Integer stationId = entity.getStationId();
+ StationThread stationThread = (StationThread) SlaveConnection.get(SlaveType.Devp, basDevp.getDevpNo());
+ if (stationThread == null) {
+ return;
+ }
+
+ Map<Integer, StationProtocol> stationMap = stationThread.getStatusMap();
+ if (stationMap == null || !stationMap.containsKey(stationId)) {
+ return;
+ }
+
+ StationProtocol stationProtocol = stationMap.get(stationId);
+ if (stationProtocol == null) {
+ return;
+ }
+
+ Object lock = redisUtil.get(RedisKeyType.STATION_IN_EXECUTE_LIMIT.key + stationId);
+ if (lock != null) {
+ return;
+ }
+
+ if (!stationProtocol.isAutoing()
+ || !stationProtocol.isLoading()
+ || stationProtocol.getTaskNo() <= 0) {
+ return;
+ }
+
+ WrkMast wrkMast = wrkMastService.getOne(new QueryWrapper<WrkMast>().eq("barcode", stationProtocol.getBarcode()));
+ if (wrkMast == null || !Objects.equals(wrkMast.getWrkSts(), WrkStsType.NEW_INBOUND.sts)) {
+ return;
+ }
+
+ String locNo = wrkMast.getLocNo();
+ FindCrnNoResult findCrnNoResult = commonService.findCrnNoByLocNo(locNo);
+ if (findCrnNoResult == null) {
+ News.taskInfo(wrkMast.getWrkNo(), "{}宸ヤ綔,鏈尮閰嶅埌鍫嗗灈鏈�", wrkMast.getWrkNo());
+ return;
+ }
+
+ Integer targetStationId = commonService.findInStationId(findCrnNoResult, stationId);
+ if (targetStationId == null) {
+ News.taskInfo(wrkMast.getWrkNo(), "{}绔欑偣,鎼滅储鍏ュ簱绔欑偣澶辫触", stationId);
+ return;
+ }
+
+ DispatchLimitConfig limitConfig = stationDispatchLoadSupport.getDispatchLimitConfig(stationProtocol.getStationId(), targetStationId);
+ int currentStationTaskCount = stationDispatchLoadSupport.countCurrentStationTask();
+ LoadGuardState loadGuardState = stationDispatchLoadSupport.buildLoadGuardState(limitConfig);
+ LoopHitResult loopHitResult = stationDispatchLoadSupport.findPathLoopHit(
+ limitConfig,
+ stationProtocol.getStationId(),
+ targetStationId,
+ loadGuardState
+ );
+ if (stationDispatchLoadSupport.isDispatchBlocked(limitConfig, currentStationTaskCount, loadGuardState, loopHitResult.isThroughLoop())) {
+ return;
+ }
+
+ StationCommand command = stationThread.getCommand(StationCommandType.MOVE, wrkMast.getWrkNo(), stationId, targetStationId, 0);
+ if (command == null) {
+ News.taskInfo(wrkMast.getWrkNo(), "{}宸ヤ綔,鑾峰彇杈撻�佺嚎鍛戒护澶辫触", wrkMast.getWrkNo());
+ return;
+ }
+
+ Date now = new Date();
+ wrkMast.setWrkSts(WrkStsType.INBOUND_STATION_RUN.sts);
+ wrkMast.setSourceStaNo(stationProtocol.getStationId());
+ wrkMast.setStaNo(targetStationId);
+ wrkMast.setSystemMsg("");
+ wrkMast.setIoTime(now);
+ wrkMast.setModiTime(now);
+ if (wrkMastService.updateById(wrkMast)) {
+ wrkAnalysisService.markInboundStationStart(wrkMast, now);
+ boolean offered = offerDevpCommandWithDedup(basDevp.getDevpNo(), command, "stationInExecute");
+ if (offered && stationMoveCoordinator != null) {
+ stationMoveCoordinator.recordDispatch(
+ wrkMast.getWrkNo(),
+ stationProtocol.getStationId(),
+ "stationInExecute",
+ command,
+ false
+ );
+ }
+ News.info("杈撻�佺珯鐐瑰叆搴撳懡浠や笅鍙戞垚鍔燂紝绔欑偣鍙�={}锛屽伐浣滃彿={}锛屽懡浠ゆ暟鎹�={}", stationId, wrkMast.getWrkNo(), JSON.toJSONString(command));
+ redisUtil.set(RedisKeyType.STATION_IN_EXECUTE_LIMIT.key + stationId, "lock", 5);
+ loadGuardState.reserveLoopTask(loopHitResult.getLoopNo());
+ stationDispatchLoadSupport.saveLoopLoadReserve(wrkMast.getWrkNo(), loopHitResult);
+ }
+ }
}
diff --git a/src/main/java/com/zy/core/utils/station/StationRerouteProcessor.java b/src/main/java/com/zy/core/utils/station/StationRerouteProcessor.java
index 42034af..9deba63 100644
--- a/src/main/java/com/zy/core/utils/station/StationRerouteProcessor.java
+++ b/src/main/java/com/zy/core/utils/station/StationRerouteProcessor.java
@@ -83,53 +83,76 @@
if (stationThread == null) {
continue;
}
-
- List<Integer> runBlockReassignLocStationList = new ArrayList<>();
- for (StationObjModel stationObjModel : basDevp.getRunBlockReassignLocStationList$()) {
- runBlockReassignLocStationList.add(stationObjModel.getStationId());
- }
- List<Integer> outOrderStationIds = basDevp.getOutOrderIntList();
-
for (StationProtocol stationProtocol : stationThread.getStatus()) {
- if (stationProtocol.isAutoing()
- && stationProtocol.isLoading()
- && stationProtocol.getTaskNo() > 0
- && stationProtocol.isRunBlock()) {
- WrkMast wrkMast = wrkMastService.selectByWorkNo(stationProtocol.getTaskNo());
- if (wrkMast == null) {
- News.info("杈撻�佺珯鐐瑰彿={} 杩愯闃诲锛屼絾鏃犳硶鎵惧埌瀵瑰簲浠诲姟锛屽伐浣滃彿={}", stationProtocol.getStationId(), stationProtocol.getTaskNo());
- continue;
- }
-
- Object lock = redisUtil.get(RedisKeyType.CHECK_STATION_RUN_BLOCK_LIMIT_.key + stationProtocol.getTaskNo());
- if (lock != null) {
- continue;
- }
- redisUtil.set(RedisKeyType.CHECK_STATION_RUN_BLOCK_LIMIT_.key + stationProtocol.getTaskNo(), "lock", 15);
-
- if (shouldUseRunBlockDirectReassign(wrkMast, stationProtocol.getStationId(), runBlockReassignLocStationList)) {
- executeRunBlockDirectReassign(basDevp, stationThread, stationProtocol, wrkMast);
- continue;
- }
-
- Double pathLenFactor = stationOutboundDecisionSupport.resolveOutboundPathLenFactor(wrkMast);
- RerouteContext context = RerouteContext.create(
- RerouteSceneType.RUN_BLOCK_REROUTE,
- basDevp,
- stationThread,
- stationProtocol,
- wrkMast,
- outOrderStationIds,
- pathLenFactor,
- "checkStationRunBlock_reroute"
- ).withRunBlockCommand()
- .withSuppressDispatchGuard()
- .withCancelSessionBeforeDispatch()
- .withResetSegmentCommandsBeforeDispatch();
- executeSharedReroute(context);
+ if (stationProtocol == null || stationProtocol.getStationId() == null) {
+ continue;
}
+ checkStationRunBlock(basDevp, stationProtocol.getStationId());
}
}
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ }
+
+ public void checkStationRunBlock(BasDevp basDevp, Integer stationId) {
+ try {
+ if (basDevp == null || basDevp.getDevpNo() == null || stationId == null) {
+ return;
+ }
+ StationThread stationThread = (StationThread) SlaveConnection.get(SlaveType.Devp, basDevp.getDevpNo());
+ if (stationThread == null) {
+ return;
+ }
+
+ Map<Integer, StationProtocol> statusMap = stationThread.getStatusMap();
+ StationProtocol stationProtocol = statusMap == null ? null : statusMap.get(stationId);
+ if (stationProtocol == null
+ || !stationProtocol.isAutoing()
+ || !stationProtocol.isLoading()
+ || stationProtocol.getTaskNo() <= 0
+ || !stationProtocol.isRunBlock()) {
+ return;
+ }
+
+ List<Integer> runBlockReassignLocStationList = new ArrayList<>();
+ for (StationObjModel stationObjModel : basDevp.getRunBlockReassignLocStationList$()) {
+ runBlockReassignLocStationList.add(stationObjModel.getStationId());
+ }
+ List<Integer> outOrderStationIds = basDevp.getOutOrderIntList();
+
+ WrkMast wrkMast = wrkMastService.selectByWorkNo(stationProtocol.getTaskNo());
+ if (wrkMast == null) {
+ News.info("杈撻�佺珯鐐瑰彿={} 杩愯闃诲锛屼絾鏃犳硶鎵惧埌瀵瑰簲浠诲姟锛屽伐浣滃彿={}", stationProtocol.getStationId(), stationProtocol.getTaskNo());
+ return;
+ }
+
+ Object lock = redisUtil.get(RedisKeyType.CHECK_STATION_RUN_BLOCK_LIMIT_.key + stationProtocol.getTaskNo());
+ if (lock != null) {
+ return;
+ }
+ redisUtil.set(RedisKeyType.CHECK_STATION_RUN_BLOCK_LIMIT_.key + stationProtocol.getTaskNo(), "lock", 15);
+
+ if (shouldUseRunBlockDirectReassign(wrkMast, stationProtocol.getStationId(), runBlockReassignLocStationList)) {
+ executeRunBlockDirectReassign(basDevp, stationThread, stationProtocol, wrkMast);
+ return;
+ }
+
+ Double pathLenFactor = stationOutboundDecisionSupport.resolveOutboundPathLenFactor(wrkMast);
+ RerouteContext context = RerouteContext.create(
+ RerouteSceneType.RUN_BLOCK_REROUTE,
+ basDevp,
+ stationThread,
+ stationProtocol,
+ wrkMast,
+ outOrderStationIds,
+ pathLenFactor,
+ "checkStationRunBlock_reroute"
+ ).withRunBlockCommand()
+ .withSuppressDispatchGuard()
+ .withCancelSessionBeforeDispatch()
+ .withResetSegmentCommandsBeforeDispatch();
+ executeSharedReroute(context);
} catch (Exception e) {
e.printStackTrace();
}
@@ -145,11 +168,8 @@
}
for (StationProtocol stationProtocol : stationThread.getStatus()) {
- if (stationProtocol.isAutoing()
- && stationProtocol.isLoading()
- && stationProtocol.getTaskNo() > 0
- && !stationProtocol.isRunBlock()) {
- checkStationIdleRecover(basDevp, stationThread, stationProtocol, basDevp.getOutOrderIntList());
+ if (stationProtocol != null && stationProtocol.getStationId() != null) {
+ checkStationIdleRecover(basDevp, stationProtocol.getStationId());
}
}
}
@@ -158,53 +178,87 @@
}
}
+ public void checkStationIdleRecover(BasDevp basDevp, Integer stationId) {
+ try {
+ if (basDevp == null || basDevp.getDevpNo() == null || stationId == null) {
+ return;
+ }
+ StationThread stationThread = (StationThread) SlaveConnection.get(SlaveType.Devp, basDevp.getDevpNo());
+ if (stationThread == null) {
+ return;
+ }
+ Map<Integer, StationProtocol> statusMap = stationThread.getStatusMap();
+ StationProtocol stationProtocol = statusMap == null ? null : statusMap.get(stationId);
+ if (stationProtocol == null
+ || !stationProtocol.isAutoing()
+ || !stationProtocol.isLoading()
+ || stationProtocol.getTaskNo() <= 0
+ || stationProtocol.isRunBlock()) {
+ return;
+ }
+ checkStationIdleRecover(basDevp, stationThread, stationProtocol, basDevp.getOutOrderIntList());
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ }
+
public void checkStationOutOrder() {
List<BasDevp> basDevps = basDevpService.list(new QueryWrapper<BasDevp>());
for (BasDevp basDevp : basDevps) {
+ List<StationObjModel> orderList = basDevp.getOutOrderList$();
+ for (StationObjModel stationObjModel : orderList) {
+ checkStationOutOrder(basDevp, stationObjModel);
+ }
+ }
+ }
+
+ public void checkStationOutOrder(BasDevp basDevp, StationObjModel stationObjModel) {
+ try {
+ if (basDevp == null || basDevp.getDevpNo() == null || stationObjModel == null || stationObjModel.getStationId() == null) {
+ return;
+ }
StationThread stationThread = (StationThread) SlaveConnection.get(SlaveType.Devp, basDevp.getDevpNo());
if (stationThread == null) {
- continue;
+ return;
}
Map<Integer, StationProtocol> statusMap = stationThread.getStatusMap();
- List<StationObjModel> orderList = basDevp.getOutOrderList$();
- List<Integer> outOrderStationIds = basDevp.getOutOrderIntList();
- for (StationObjModel stationObjModel : orderList) {
- StationProtocol stationProtocol = statusMap.get(stationObjModel.getStationId());
- if (stationProtocol == null
- || !stationProtocol.isAutoing()
- || !stationProtocol.isLoading()
- || stationProtocol.getTaskNo() <= 0
- || stationProtocol.isRunBlock()
- || !stationProtocol.getStationId().equals(stationProtocol.getTargetStaNo())) {
- continue;
- }
-
- WrkMast wrkMast = wrkMastService.selectByWorkNo(stationProtocol.getTaskNo());
- if (wrkMast == null
- || !Objects.equals(wrkMast.getWrkSts(), WrkStsType.STATION_RUN.sts)
- || Objects.equals(stationProtocol.getStationId(), wrkMast.getStaNo())) {
- continue;
- }
- if (stationOutboundDecisionSupport.shouldSkipOutOrderDispatchForExistingRoute(wrkMast.getWrkNo(), stationProtocol.getStationId())) {
- continue;
- }
-
- Double pathLenFactor = stationOutboundDecisionSupport.resolveOutboundPathLenFactor(wrkMast);
- RerouteContext context = RerouteContext.create(
- RerouteSceneType.OUT_ORDER,
- basDevp,
- stationThread,
- stationProtocol,
- wrkMast,
- outOrderStationIds,
- pathLenFactor,
- "checkStationOutOrder"
- ).withDispatchDeviceNo(stationObjModel.getDeviceNo())
- .withSuppressDispatchGuard()
- .withOutOrderDispatchLock()
- .withResetSegmentCommandsBeforeDispatch();
- executeSharedReroute(context);
+ StationProtocol stationProtocol = statusMap == null ? null : statusMap.get(stationObjModel.getStationId());
+ if (stationProtocol == null
+ || !stationProtocol.isAutoing()
+ || !stationProtocol.isLoading()
+ || stationProtocol.getTaskNo() <= 0
+ || stationProtocol.isRunBlock()
+ || !stationProtocol.getStationId().equals(stationProtocol.getTargetStaNo())) {
+ return;
}
+
+ WrkMast wrkMast = wrkMastService.selectByWorkNo(stationProtocol.getTaskNo());
+ if (wrkMast == null
+ || !Objects.equals(wrkMast.getWrkSts(), WrkStsType.STATION_RUN.sts)
+ || Objects.equals(stationProtocol.getStationId(), wrkMast.getStaNo())) {
+ return;
+ }
+ if (stationOutboundDecisionSupport.shouldSkipOutOrderDispatchForExistingRoute(wrkMast.getWrkNo(), stationProtocol.getStationId())) {
+ return;
+ }
+
+ Double pathLenFactor = stationOutboundDecisionSupport.resolveOutboundPathLenFactor(wrkMast);
+ RerouteContext context = RerouteContext.create(
+ RerouteSceneType.OUT_ORDER,
+ basDevp,
+ stationThread,
+ stationProtocol,
+ wrkMast,
+ basDevp.getOutOrderIntList(),
+ pathLenFactor,
+ "checkStationOutOrder"
+ ).withDispatchDeviceNo(stationObjModel.getDeviceNo())
+ .withSuppressDispatchGuard()
+ .withOutOrderDispatchLock()
+ .withResetSegmentCommandsBeforeDispatch();
+ executeSharedReroute(context);
+ } catch (Exception e) {
+ e.printStackTrace();
}
}
@@ -215,41 +269,60 @@
if (stationThread == null) {
continue;
}
-
- List<Integer> outOrderList = basDevp.getOutOrderIntList();
for (StationProtocol stationProtocol : stationThread.getStatus()) {
- if (!stationProtocol.isAutoing()
- || !stationProtocol.isLoading()
- || stationProtocol.getTaskNo() <= 0
- || !stationOutboundDecisionSupport.isWatchingCircleArrival(stationProtocol.getTaskNo(), stationProtocol.getStationId())) {
+ if (stationProtocol == null || stationProtocol.getStationId() == null) {
continue;
}
-
- WrkMast wrkMast = wrkMastService.selectByWorkNo(stationProtocol.getTaskNo());
- if (wrkMast == null
- || !Objects.equals(wrkMast.getWrkSts(), WrkStsType.STATION_RUN.sts)
- || Objects.equals(stationProtocol.getStationId(), wrkMast.getStaNo())) {
- continue;
- }
-
- Double pathLenFactor = stationOutboundDecisionSupport.resolveOutboundPathLenFactor(wrkMast);
- RerouteContext context = RerouteContext.create(
- RerouteSceneType.WATCH_CIRCLE,
- basDevp,
- stationThread,
- stationProtocol,
- wrkMast,
- outOrderList,
- pathLenFactor,
- "watchCircleStation"
- ).withSuppressDispatchGuard()
- .withOutOrderDispatchLock()
- .withResetSegmentCommandsBeforeDispatch();
- executeSharedReroute(context);
+ watchCircleStation(basDevp, stationProtocol.getStationId());
}
}
}
+ public void watchCircleStation(BasDevp basDevp, Integer stationId) {
+ try {
+ if (basDevp == null || basDevp.getDevpNo() == null || stationId == null) {
+ return;
+ }
+ StationThread stationThread = (StationThread) SlaveConnection.get(SlaveType.Devp, basDevp.getDevpNo());
+ if (stationThread == null) {
+ return;
+ }
+ Map<Integer, StationProtocol> statusMap = stationThread.getStatusMap();
+ StationProtocol stationProtocol = statusMap == null ? null : statusMap.get(stationId);
+ if (stationProtocol == null
+ || !stationProtocol.isAutoing()
+ || !stationProtocol.isLoading()
+ || stationProtocol.getTaskNo() <= 0
+ || !stationOutboundDecisionSupport.isWatchingCircleArrival(stationProtocol.getTaskNo(), stationProtocol.getStationId())) {
+ return;
+ }
+
+ WrkMast wrkMast = wrkMastService.selectByWorkNo(stationProtocol.getTaskNo());
+ if (wrkMast == null
+ || !Objects.equals(wrkMast.getWrkSts(), WrkStsType.STATION_RUN.sts)
+ || Objects.equals(stationProtocol.getStationId(), wrkMast.getStaNo())) {
+ return;
+ }
+
+ Double pathLenFactor = stationOutboundDecisionSupport.resolveOutboundPathLenFactor(wrkMast);
+ RerouteContext context = RerouteContext.create(
+ RerouteSceneType.WATCH_CIRCLE,
+ basDevp,
+ stationThread,
+ stationProtocol,
+ wrkMast,
+ basDevp.getOutOrderIntList(),
+ pathLenFactor,
+ "watchCircleStation"
+ ).withSuppressDispatchGuard()
+ .withOutOrderDispatchLock()
+ .withResetSegmentCommandsBeforeDispatch();
+ executeSharedReroute(context);
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ }
+
public RerouteCommandPlan buildRerouteCommandPlan(RerouteContext context,
RerouteDecision decision) {
if (context == null) {
--
Gitblit v1.9.1