From 63a8366af4391d1717d7555ab6c01f984f501f7b Mon Sep 17 00:00:00 2001
From: Junjie <fallin.jie@qq.com>
Date: 星期五, 20 三月 2026 20:35:28 +0800
Subject: [PATCH] #
---
src/main/java/com/zy/core/utils/StationOperateProcessUtils.java | 1496 ++++++++++++++++++++++++++++++++++++++++++++++++++---------
1 files changed, 1,264 insertions(+), 232 deletions(-)
diff --git a/src/main/java/com/zy/core/utils/StationOperateProcessUtils.java b/src/main/java/com/zy/core/utils/StationOperateProcessUtils.java
index 8237bbe..27c84fc 100644
--- a/src/main/java/com/zy/core/utils/StationOperateProcessUtils.java
+++ b/src/main/java/com/zy/core/utils/StationOperateProcessUtils.java
@@ -2,13 +2,22 @@
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
-import com.baomidou.mybatisplus.mapper.EntityWrapper;
+import com.alibaba.fastjson.serializer.SerializerFeature;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.core.common.Cools;
import com.core.exception.CoolException;
+import com.zy.asrs.domain.enums.NotifyMsgType;
+import com.zy.asrs.domain.path.StationPathResolvedPolicy;
+import com.zy.asrs.domain.vo.StationCycleCapacityVo;
+import com.zy.asrs.domain.vo.StationCycleLoopVo;
import com.zy.asrs.entity.*;
import com.zy.asrs.service.*;
+import com.zy.asrs.utils.NotifyUtils;
import com.zy.common.entity.FindCrnNoResult;
+import com.zy.common.model.NavigateNode;
import com.zy.common.model.StartupDto;
import com.zy.common.service.CommonService;
+import com.zy.common.utils.NavigateUtils;
import com.zy.common.utils.RedisUtil;
import com.zy.core.News;
import com.zy.core.cache.MessageQueue;
@@ -26,6 +35,11 @@
@Component
public class StationOperateProcessUtils {
+ private static final int LOOP_LOAD_RESERVE_EXPIRE_SECONDS = 120;
+ private static final int OUT_ORDER_DISPATCH_LIMIT_SECONDS = 10;
+ private static final int STATION_IDLE_RECOVER_SECONDS = 10;
+ private static final int STATION_IDLE_RECOVER_LIMIT_SECONDS = 10;
+ private static final int STATION_IDLE_TRACK_EXPIRE_SECONDS = 60 * 60;
@Autowired
private BasDevpService basDevpService;
@@ -34,120 +48,216 @@
@Autowired
private CommonService commonService;
@Autowired
- private BasCrnpService basCrnpService;
- @Autowired
- private BasDualCrnpService basDualCrnpService;
- @Autowired
private RedisUtil redisUtil;
@Autowired
private LocMastService locMastService;
@Autowired
private WmsOperateUtils wmsOperateUtils;
+ @Autowired
+ private NotifyUtils notifyUtils;
+ @Autowired
+ private NavigateUtils navigateUtils;
+ @Autowired
+ private BasStationService basStationService;
+ @Autowired
+ private StationCycleCapacityService stationCycleCapacityService;
+ @Autowired
+ private StationPathPolicyService stationPathPolicyService;
+ @Autowired
+ private BasStationOptService basStationOptService;
//鎵ц杈撻�佺珯鐐瑰叆搴撲换鍔�
public synchronized void stationInExecute() {
- List<BasDevp> basDevps = basDevpService.selectList(new EntityWrapper<>());
- for (BasDevp basDevp : basDevps) {
- StationThread stationThread = (StationThread) SlaveConnection.get(SlaveType.Devp, basDevp.getDevpNo());
- if(stationThread == null){
- continue;
- }
+ try {
+ DispatchLimitConfig baseLimitConfig = getDispatchLimitConfig(null, null);
+ int[] currentStationTaskCountRef = new int[]{countCurrentStationTask()};
+ LoadGuardState loadGuardState = buildLoadGuardState(baseLimitConfig);
- Map<Integer, StationProtocol> stationMap = stationThread.getStatusMap();
-
- List<StationObjModel> list = basDevp.getBarcodeStationList$();
- for (StationObjModel entity : list) {
- Integer stationId = entity.getStationId();
- if(!stationMap.containsKey(stationId)){
+ List<BasDevp> basDevps = basDevpService.list(new QueryWrapper<>());
+ for (BasDevp basDevp : basDevps) {
+ StationThread stationThread = (StationThread) SlaveConnection.get(SlaveType.Devp, basDevp.getDevpNo());
+ if (stationThread == null) {
continue;
}
- StationProtocol stationProtocol = stationMap.get(stationId);
+ Map<Integer, StationProtocol> stationMap = stationThread.getStatusMap();
+
+ List<StationObjModel> list = basDevp.getBarcodeStationList$();
+ for (StationObjModel entity : list) {
+ 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
+ ) {
+ //妫�娴嬩换鍔℃槸鍚︾敓鎴�
+ WrkMast wrkMast = wrkMastService.getOne(new QueryWrapper<WrkMast>().eq("barcode", stationProtocol.getBarcode()));
+ if (wrkMast == null) {
+ continue;
+ }
+
+ if (wrkMast.getWrkSts() == WrkStsType.INBOUND_DEVICE_RUN.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 = getDispatchLimitConfig(stationProtocol.getStationId(), targetStationId);
+ LoopHitResult loopHitResult = findPathLoopHit(limitConfig, stationProtocol.getStationId(), targetStationId, loadGuardState);
+
+ if (isDispatchBlocked(limitConfig, currentStationTaskCountRef[0], loadGuardState, loopHitResult.isThroughLoop())) {
+ return;
+ }
+
+ StationCommand command = stationThread.getCommand(StationCommandType.MOVE, wrkMast.getWrkNo(), stationId, targetStationId, 0);
+ if (command == null) {
+ News.taskInfo(wrkMast.getWrkNo(), "{}宸ヤ綔,鑾峰彇杈撻�佺嚎鍛戒护澶辫触", wrkMast.getWrkNo());
+ continue;
+ }
+
+ wrkMast.setWrkSts(WrkStsType.INBOUND_DEVICE_RUN.sts);
+ wrkMast.setSourceStaNo(stationProtocol.getStationId());
+ wrkMast.setStaNo(targetStationId);
+ wrkMast.setSystemMsg("");
+ wrkMast.setIoTime(new Date());
+ if (wrkMastService.updateById(wrkMast)) {
+ MessageQueue.offer(SlaveType.Devp, basDevp.getDevpNo(), new Task(2, command));
+ News.info("杈撻�佺珯鐐瑰叆搴撳懡浠や笅鍙戞垚鍔燂紝绔欑偣鍙�={}锛屽伐浣滃彿={}锛屽懡浠ゆ暟鎹�={}", stationId, wrkMast.getWrkNo(), JSON.toJSONString(command));
+ redisUtil.set(RedisKeyType.STATION_IN_EXECUTE_LIMIT.key + stationId, "lock", 5);
+ loadGuardState.reserveLoopTask(loopHitResult.getLoopNo());
+ saveLoopLoadReserve(wrkMast.getWrkNo(), loopHitResult);
+ }
+ }
+ }
+ }
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ }
+
+ //鎵ц鍫嗗灈鏈鸿緭閫佺珯鐐瑰嚭搴撲换鍔�
+ public synchronized void crnStationOutExecute() {
+ try {
+ DispatchLimitConfig baseLimitConfig = getDispatchLimitConfig(null, null);
+ int[] currentStationTaskCountRef = new int[]{countCurrentStationTask()};
+ LoadGuardState loadGuardState = buildLoadGuardState(baseLimitConfig);
+
+ List<WrkMast> wrkMasts = wrkMastService.list(new QueryWrapper<WrkMast>()
+ .eq("wrk_sts", WrkStsType.OUTBOUND_RUN_COMPLETE.sts)
+ .isNotNull("crn_no")
+ );
+ List<Integer> outOrderList = 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;
+ }
+
+ StationObjModel stationObjModel = JSON.parseObject(infoObj.toString(), StationObjModel.class);
+ StationThread stationThread = (StationThread) SlaveConnection.get(SlaveType.Devp, stationObjModel.getDeviceNo());
+ if (stationThread == null) {
+ continue;
+ }
+
+ Map<Integer, StationProtocol> stationMap = stationThread.getStatusMap();
+ StationProtocol stationProtocol = stationMap.get(stationObjModel.getStationId());
if (stationProtocol == null) {
continue;
}
- Object lock = redisUtil.get(RedisKeyType.STATION_IN_EXECUTE_LIMIT.key + stationId);
- if(lock != null){
+ Object lock = redisUtil.get(RedisKeyType.STATION_OUT_EXECUTE_LIMIT.key + stationProtocol.getStationId());
+ if (lock != null) {
continue;
}
- //婊¤冻鑷姩銆佹湁鐗┿�佹湁宸ヤ綔鍙�
+ //婊¤冻鑷姩銆佹湁鐗┿�佸伐浣滃彿0
if (stationProtocol.isAutoing()
&& stationProtocol.isLoading()
- && stationProtocol.getTaskNo() > 0
+ && stationProtocol.getTaskNo() == 0
) {
- //妫�娴嬩换鍔℃槸鍚︾敓鎴�
- WrkMast wrkMast = wrkMastService.selectOne(new EntityWrapper<WrkMast>().eq("barcode", stationProtocol.getBarcode()));
- if (wrkMast == null) {
+ Integer moveStaNo = resolveDispatchOutOrderTarget(
+ stationProtocol.getStationId(),
+ wrkMast.getStaNo(),
+ outOrderList,
+ true
+ );
+
+ DispatchLimitConfig limitConfig = getDispatchLimitConfig(stationProtocol.getStationId(), moveStaNo);
+ LoopHitResult loopHitResult = findPathLoopHit(limitConfig, stationProtocol.getStationId(), moveStaNo, loadGuardState);
+
+ if (isDispatchBlocked(limitConfig, currentStationTaskCountRef[0], loadGuardState, loopHitResult.isThroughLoop())) {
+ return;
+ }
+
+ StationCommand command = stationThread.getCommand(StationCommandType.MOVE, wrkMast.getWrkNo(), stationProtocol.getStationId(), moveStaNo, 0);
+ if (command == null) {
+ News.taskInfo(wrkMast.getWrkNo(), "鑾峰彇杈撻�佺嚎鍛戒护澶辫触");
continue;
}
- if (wrkMast.getWrkSts() == WrkStsType.INBOUND_DEVICE_RUN.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;
- }
-
- StationCommand command = stationThread.getCommand(StationCommandType.MOVE, wrkMast.getWrkNo(), stationId, targetStationId, 0);
- if(command == null){
- News.taskInfo(wrkMast.getWrkNo(), "{}宸ヤ綔,鑾峰彇杈撻�佺嚎鍛戒护澶辫触", wrkMast.getWrkNo());
- continue;
- }
-
- wrkMast.setWrkSts(WrkStsType.INBOUND_DEVICE_RUN.sts);
- wrkMast.setSourceStaNo(stationProtocol.getStationId());
- wrkMast.setStaNo(targetStationId);
+ wrkMast.setWrkSts(WrkStsType.STATION_RUN.sts);
wrkMast.setSystemMsg("");
wrkMast.setIoTime(new Date());
if (wrkMastService.updateById(wrkMast)) {
- MessageQueue.offer(SlaveType.Devp, basDevp.getDevpNo(), new Task(2, command));
- News.info("杈撻�佺珯鐐瑰叆搴撳懡浠や笅鍙戞垚鍔燂紝绔欑偣鍙�={}锛屽伐浣滃彿={}锛屽懡浠ゆ暟鎹�={}", stationId, wrkMast.getWrkNo(), JSON.toJSONString(command));
- redisUtil.set(RedisKeyType.STATION_IN_EXECUTE_LIMIT.key + stationId, "lock", 5);
+ MessageQueue.offer(SlaveType.Devp, stationObjModel.getDeviceNo(), new Task(2, command));
+ 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());
+ saveLoopLoadReserve(wrkMast.getWrkNo(), loopHitResult);
}
}
}
+ } catch (Exception e) {
+ e.printStackTrace();
}
}
- //鎵ц杈撻�佺珯鐐瑰嚭搴撲换鍔�
- public synchronized void stationOutExecute() {
- List<WrkMast> wrkMasts = wrkMastService.selectList(new EntityWrapper<WrkMast>().eq("wrk_sts", WrkStsType.OUTBOUND_RUN_COMPLETE.sts));
- for (WrkMast wrkMast : wrkMasts) {
- List<StationObjModel> outStationList = new ArrayList<>();
-
- BasCrnp basCrnp = basCrnpService.selectOne(new EntityWrapper<BasCrnp>().eq("crn_no", wrkMast.getCrnNo()));
- if (basCrnp != null) {
- outStationList = basCrnp.getOutStationList$();
- if(outStationList.isEmpty()){
- News.info("鍫嗗灈鏈�:{} 鍑哄簱绔欑偣鏈缃�", basCrnp.getCrnNo());
+ //鎵ц鍙屽伐浣嶅爢鍨涙満杈撻�佺珯鐐瑰嚭搴撲换鍔�
+ public synchronized void dualCrnStationOutExecute() {
+ try {
+ List<WrkMast> wrkMasts = wrkMastService.list(new QueryWrapper<WrkMast>()
+ .eq("wrk_sts", WrkStsType.OUTBOUND_RUN_COMPLETE.sts)
+ .isNotNull("dual_crn_no")
+ );
+ for (WrkMast wrkMast : wrkMasts) {
+ Object infoObj = redisUtil.get(RedisKeyType.DUAL_CRN_OUT_TASK_STATION_INFO.key + wrkMast.getWrkNo());
+ if (infoObj == null) {
+ News.info("鍑哄簱浠诲姟{}鏁版嵁缂撳瓨涓嶅瓨鍦�", wrkMast.getWrkNo());
continue;
}
- }
- BasDualCrnp basDualCrnp = basDualCrnpService.selectOne(new EntityWrapper<BasDualCrnp>().eq("crn_no", wrkMast.getDualCrnNo()));
- if (basDualCrnp != null) {
- outStationList = basDualCrnp.getOutStationList$();
- if(outStationList.isEmpty()){
- News.info("鍙屽伐浣嶅爢鍨涙満:{} 鍑哄簱绔欑偣鏈缃�", basDualCrnp.getCrnNo());
- continue;
- }
- }
-
- for (StationObjModel stationObjModel : outStationList) {
+ StationObjModel stationObjModel = JSON.parseObject(infoObj.toString(), StationObjModel.class);
StationThread stationThread = (StationThread) SlaveConnection.get(SlaveType.Devp, stationObjModel.getDeviceNo());
- if(stationThread == null){
+ if (stationThread == null) {
continue;
}
@@ -168,7 +278,7 @@
&& stationProtocol.getTaskNo() == 0
) {
StationCommand command = stationThread.getCommand(StationCommandType.MOVE, wrkMast.getWrkNo(), stationProtocol.getStationId(), wrkMast.getStaNo(), 0);
- if(command == null){
+ if (command == null) {
News.taskInfo(wrkMast.getWrkNo(), "鑾峰彇杈撻�佺嚎鍛戒护澶辫触");
continue;
}
@@ -178,28 +288,250 @@
wrkMast.setIoTime(new Date());
if (wrkMastService.updateById(wrkMast)) {
MessageQueue.offer(SlaveType.Devp, stationObjModel.getDeviceNo(), new Task(2, command));
+ notifyUtils.notify(String.valueOf(SlaveType.Devp), stationObjModel.getDeviceNo(), String.valueOf(wrkMast.getWrkNo()), wrkMast.getWmsWrkNo(), NotifyMsgType.STATION_OUT_TASK_RUN, null);
News.info("杈撻�佺珯鐐瑰嚭搴撳懡浠や笅鍙戞垚鍔燂紝绔欑偣鍙�={}锛屽伐浣滃彿={}锛屽懡浠ゆ暟鎹�={}", stationProtocol.getStationId(), wrkMast.getWrkNo(), JSON.toJSONString(command));
redisUtil.set(RedisKeyType.STATION_OUT_EXECUTE_LIMIT.key + stationProtocol.getStationId(), "lock", 5);
- redisUtil.set(RedisKeyType.STATION_OUT_EXECUTE_COMPLETE_LIMIT.key + wrkMast.getWrkNo(), "lock", 60 * 5);
+ redisUtil.del(RedisKeyType.DUAL_CRN_OUT_TASK_STATION_INFO.key + wrkMast.getWrkNo());
}
}
}
+ } catch (Exception e) {
+ e.printStackTrace();
}
}
//妫�娴嬭緭閫佺珯鐐瑰嚭搴撲换鍔℃墽琛屽畬鎴�
public synchronized void stationOutExecuteFinish() {
- List<WrkMast> wrkMasts = wrkMastService.selectList(new EntityWrapper<WrkMast>().eq("wrk_sts", WrkStsType.STATION_RUN.sts));
- for (WrkMast wrkMast : wrkMasts) {
- Integer wrkNo = wrkMast.getWrkNo();
+ 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();
- Object lock = redisUtil.get(RedisKeyType.STATION_OUT_EXECUTE_COMPLETE_LIMIT.key + wrkNo);
- if (lock != null) {
- continue;
+ boolean complete = false;
+ BasStation basStation = basStationService.getOne(new QueryWrapper<BasStation>().eq("station_id", targetStaNo));
+ if (basStation == null) {
+ continue;
+ }
+
+ StationThread stationThread = (StationThread) SlaveConnection.get(SlaveType.Devp, basStation.getDeviceNo());
+ if (stationThread == null) {
+ continue;
+ }
+
+ Map<Integer, StationProtocol> statusMap = stationThread.getStatusMap();
+ StationProtocol stationProtocol = statusMap.get(basStation.getStationId());
+ if (stationProtocol == null) {
+ continue;
+ }
+
+ if (stationProtocol.getTaskNo().equals(wrkNo)) {
+ complete = true;
+ }
+
+ if (complete) {
+ wrkMast.setWrkSts(WrkStsType.STATION_RUN_COMPLETE.sts);
+ wrkMast.setIoTime(new Date());
+ wrkMastService.updateById(wrkMast);
+ notifyUtils.notify(String.valueOf(SlaveType.Devp), basStation.getDeviceNo(), String.valueOf(wrkMast.getWrkNo()), wrkMast.getWmsWrkNo(), NotifyMsgType.STATION_OUT_TASK_RUN_COMPLETE, null);
+ redisUtil.set(RedisKeyType.STATION_OUT_EXECUTE_COMPLETE_LIMIT.key + wrkMast.getWrkNo(), "lock", 60);
+ }
}
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ }
- boolean complete = true;
- List<BasDevp> basDevps = basDevpService.selectList(new EntityWrapper<>());
+ // 妫�娴嬩换鍔¤浆瀹屾垚
+ public synchronized void checkTaskToComplete() {
+ 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();
+
+ Object lock = redisUtil.get(RedisKeyType.STATION_OUT_EXECUTE_COMPLETE_LIMIT.key + wrkNo);
+ if (lock != null) {
+ continue;
+ }
+
+ boolean complete = false;
+ BasStation basStation = basStationService.getOne(new QueryWrapper<BasStation>().eq("station_id", targetStaNo));
+ if (basStation == null) {
+ continue;
+ }
+
+ StationThread stationThread = (StationThread) SlaveConnection.get(SlaveType.Devp, basStation.getDeviceNo());
+ if (stationThread == null) {
+ continue;
+ }
+
+ Map<Integer, StationProtocol> statusMap = stationThread.getStatusMap();
+ StationProtocol stationProtocol = statusMap.get(basStation.getStationId());
+ if (stationProtocol == null) {
+ continue;
+ }
+
+ if (!stationProtocol.getTaskNo().equals(wrkNo)) {
+ complete = true;
+ }
+
+ if (complete) {
+ wrkMast.setWrkSts(WrkStsType.COMPLETE_OUTBOUND.sts);
+ wrkMast.setIoTime(new Date());
+ wrkMastService.updateById(wrkMast);
+ }
+ }
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ }
+
+ //妫�娴嬭緭閫佺珯鐐规槸鍚﹁繍琛屽牭濉�
+ public synchronized void checkStationRunBlock() {
+ try {
+ List<BasDevp> basDevps = basDevpService.list(new QueryWrapper<>());
+ for (BasDevp basDevp : basDevps) {
+ StationThread stationThread = (StationThread) SlaveConnection.get(SlaveType.Devp, basDevp.getDevpNo());
+ if (stationThread == null) {
+ continue;
+ }
+
+ List<Integer> runBlockReassignLocStationList = new ArrayList<>();
+ for (StationObjModel stationObjModel : basDevp.getRunBlockReassignLocStationList$()) {
+ runBlockReassignLocStationList.add(stationObjModel.getStationId());
+ }
+
+ List<StationProtocol> list = stationThread.getStatus();
+ for (StationProtocol stationProtocol : list) {
+ 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 (wrkMast.getIoType() == WrkIoType.IN.id && runBlockReassignLocStationList.contains(stationProtocol.getStationId())) {
+ //绔欑偣澶勪簬閲嶆柊鍒嗛厤搴撲綅鍖哄煙
+ //杩愯鍫靛锛岄噸鏂扮敵璇蜂换鍔�
+ String response = wmsOperateUtils.applyReassignTaskLocNo(wrkMast.getWrkNo(), stationProtocol.getStationId());
+ if (Cools.isEmpty(response)) {
+ News.taskError(wrkMast.getWrkNo(), "璇锋眰WMS閲嶆柊鍒嗛厤搴撲綅鎺ュ彛澶辫触锛屾帴鍙ｆ湭鍝嶅簲锛侊紒锛乺esponse锛歿}", response);
+ continue;
+ }
+ JSONObject jsonObject = JSON.parseObject(response);
+ if (jsonObject.getInteger("code").equals(200)) {
+ StartupDto dto = jsonObject.getObject("data", StartupDto.class);
+
+ String sourceLocNo = wrkMast.getLocNo();
+ String locNo = dto.getLocNo();
+
+ LocMast sourceLocMast = locMastService.queryByLoc(sourceLocNo);
+ if (sourceLocMast == null) {
+ News.taskInfo(wrkMast.getWrkNo(), "搴撲綅鍙�:{} 婧愬簱浣嶄俊鎭笉瀛樺湪", sourceLocNo);
+ continue;
+ }
+
+ if (!sourceLocMast.getLocSts().equals("S")) {
+ News.taskInfo(wrkMast.getWrkNo(), "搴撲綅鍙�:{} 婧愬簱浣嶇姸鎬佷笉澶勪簬鍏ュ簱棰勭害", sourceLocNo);
+ continue;
+ }
+
+ LocMast locMast = locMastService.queryByLoc(locNo);
+ if (locMast == null) {
+ News.taskInfo(wrkMast.getWrkNo(), "搴撲綅鍙�:{} 鐩爣搴撲綅淇℃伅涓嶅瓨鍦�", locNo);
+ continue;
+ }
+
+ if (!locMast.getLocSts().equals("O")) {
+ News.taskInfo(wrkMast.getWrkNo(), "搴撲綅鍙�:{} 鐩爣搴撲綅鐘舵�佷笉澶勪簬绌哄簱浣�", locNo);
+ continue;
+ }
+
+ FindCrnNoResult findCrnNoResult = commonService.findCrnNoByLocNo(locNo);
+ if (findCrnNoResult == null) {
+ News.taskInfo(wrkMast.getWrkNo(), "{}宸ヤ綔,鏈尮閰嶅埌鍫嗗灈鏈�", wrkMast.getWrkNo());
+ continue;
+ }
+ Integer crnNo = findCrnNoResult.getCrnNo();
+
+ Integer targetStationId = commonService.findInStationId(findCrnNoResult, stationProtocol.getStationId());
+ if (targetStationId == null) {
+ News.taskInfo(wrkMast.getWrkNo(), "{}绔欑偣,鎼滅储鍏ュ簱绔欑偣澶辫触", stationProtocol.getStationId());
+ continue;
+ }
+
+ StationCommand command = stationThread.getCommand(StationCommandType.MOVE, wrkMast.getWrkNo(), stationProtocol.getStationId(), targetStationId, 0);
+ if (command == null) {
+ News.taskInfo(wrkMast.getWrkNo(), "{}宸ヤ綔,鑾峰彇杈撻�佺嚎鍛戒护澶辫触", wrkMast.getWrkNo());
+ continue;
+ }
+
+ //鏇存柊婧愬簱浣�
+ sourceLocMast.setLocSts("O");
+ sourceLocMast.setModiTime(new Date());
+ locMastService.updateById(sourceLocMast);
+
+ //鏇存柊鐩爣搴撲綅
+ locMast.setLocSts("S");
+ locMast.setModiTime(new Date());
+ locMastService.updateById(locMast);
+
+ //鏇存柊宸ヤ綔妗ｆ暟鎹�
+ wrkMast.setLocNo(locNo);
+ wrkMast.setStaNo(targetStationId);
+
+ if (findCrnNoResult.getCrnType().equals(SlaveType.Crn)) {
+ wrkMast.setCrnNo(crnNo);
+ } else if (findCrnNoResult.getCrnType().equals(SlaveType.DualCrn)) {
+ wrkMast.setDualCrnNo(crnNo);
+ } else {
+ throw new CoolException("鏈煡璁惧绫诲瀷");
+ }
+
+ if (wrkMastService.updateById(wrkMast)) {
+ MessageQueue.offer(SlaveType.Devp, basDevp.getDevpNo(), new Task(2, command));
+ }
+ } else {
+ News.error("璇锋眰WMS鎺ュ彛澶辫触锛侊紒锛乺esponse锛歿}", response);
+ }
+ } else {
+ //杩愯鍫靛锛岄噸鏂拌绠楄矾绾�
+ StationCommand command = stationThread.getCommand(StationCommandType.MOVE, wrkMast.getWrkNo(), stationProtocol.getStationId(), wrkMast.getStaNo(), 0);
+ if (command == null) {
+ News.taskInfo(wrkMast.getWrkNo(), "鑾峰彇杈撻�佺嚎鍛戒护澶辫触");
+ continue;
+ }
+
+ MessageQueue.offer(SlaveType.Devp, basDevp.getDevpNo(), new Task(2, command));
+ News.info("杈撻�佺珯鐐瑰牭濉炲悗閲嶆柊璁＄畻璺緞鍛戒护涓嬪彂鎴愬姛锛岀珯鐐瑰彿={}锛屽伐浣滃彿={}锛屽懡浠ゆ暟鎹�={}", stationProtocol.getStationId(), wrkMast.getWrkNo(), JSON.toJSONString(command));
+ }
+ }
+ }
+ }
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ }
+
+ //妫�娴嬭緭閫佺珯鐐逛换鍔″仠鐣欒秴鏃跺悗閲嶆柊璁＄畻璺緞
+ public synchronized void checkStationIdleRecover() {
+ try {
+ List<BasDevp> basDevps = basDevpService.list(new QueryWrapper<>());
+ List<Integer> outOrderList = new ArrayList<>();
+ for (BasDevp basDevp : basDevps) {
+ outOrderList.addAll(basDevp.getOutOrderIntList());
+ }
for (BasDevp basDevp : basDevps) {
StationThread stationThread = (StationThread) SlaveConnection.get(SlaveType.Devp, basDevp.getDevpNo());
if (stationThread == null) {
@@ -208,159 +540,523 @@
List<StationProtocol> list = stationThread.getStatus();
for (StationProtocol stationProtocol : list) {
- if (stationProtocol.getTaskNo().equals(wrkNo)) {
- complete = false;
+ if (stationProtocol.isAutoing()
+ && stationProtocol.isLoading()
+ && stationProtocol.getTaskNo() > 0
+ && !stationProtocol.isRunBlock()
+ ) {
+ checkStationIdleRecover(basDevp, stationThread, stationProtocol, outOrderList);
}
}
}
-
- if (complete) {
- wrkMast.setWrkSts(WrkStsType.COMPLETE_OUTBOUND.sts);
- wrkMast.setIoTime(new Date());
- wrkMastService.updateById(wrkMast);
- }
- }
- }
-
- //妫�娴嬭緭閫佺珯鐐规槸鍚﹁繍琛屽牭濉�
- public synchronized void checkStationRunBlock() {
- List<BasDevp> basDevps = basDevpService.selectList(new EntityWrapper<>());
- for (BasDevp basDevp : basDevps) {
- StationThread stationThread = (StationThread) SlaveConnection.get(SlaveType.Devp, basDevp.getDevpNo());
- if(stationThread == null){
- continue;
- }
-
- List<Integer> runBlockReassignLocStationList = new ArrayList<>();
- for (StationObjModel stationObjModel : basDevp.getRunBlockReassignLocStationList$()) {
- runBlockReassignLocStationList.add(stationObjModel.getStationId());
- }
-
- List<StationProtocol> list = stationThread.getStatus();
- for (StationProtocol stationProtocol : list) {
- 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 (wrkMast.getIoType() == WrkIoType.IN.id && runBlockReassignLocStationList.contains(stationProtocol.getStationId())) {
- //绔欑偣澶勪簬閲嶆柊鍒嗛厤搴撲綅鍖哄煙
- //杩愯鍫靛锛岄噸鏂扮敵璇蜂换鍔�
- String response = wmsOperateUtils.applyReassignTaskLocNo(wrkMast.getWrkNo(), stationProtocol.getStationId());
- if (response == null) {
- News.taskError(wrkMast.getWrkNo(), "璇锋眰WMS閲嶆柊鍒嗛厤搴撲綅鎺ュ彛澶辫触锛屾帴鍙ｆ湭鍝嶅簲锛侊紒锛乺esponse锛歿}", response);
- continue;
- }
- JSONObject jsonObject = JSON.parseObject(response);
- if (jsonObject.getInteger("code").equals(200)) {
- StartupDto dto = jsonObject.getObject("data", StartupDto.class);
-
- String sourceLocNo = wrkMast.getLocNo();
- String locNo = dto.getLocNo();
-
- LocMast sourceLocMast = locMastService.queryByLoc(sourceLocNo);
- if (sourceLocMast == null) {
- News.taskInfo(wrkMast.getWrkNo(), "搴撲綅鍙�:{} 婧愬簱浣嶄俊鎭笉瀛樺湪", sourceLocNo);
- continue;
- }
-
- if (!sourceLocMast.getLocSts().equals("S")) {
- News.taskInfo(wrkMast.getWrkNo(), "搴撲綅鍙�:{} 婧愬簱浣嶇姸鎬佷笉澶勪簬鍏ュ簱棰勭害", sourceLocNo);
- continue;
- }
-
- LocMast locMast = locMastService.queryByLoc(locNo);
- if (locMast == null) {
- News.taskInfo(wrkMast.getWrkNo(), "搴撲綅鍙�:{} 鐩爣搴撲綅淇℃伅涓嶅瓨鍦�", locNo);
- continue;
- }
-
- if (!locMast.getLocSts().equals("O")) {
- News.taskInfo(wrkMast.getWrkNo(), "搴撲綅鍙�:{} 鐩爣搴撲綅鐘舵�佷笉澶勪簬绌哄簱浣�", locNo);
- continue;
- }
-
- FindCrnNoResult findCrnNoResult = commonService.findCrnNoByLocNo(locNo);
- if (findCrnNoResult == null) {
- News.taskInfo(wrkMast.getWrkNo(), "{}宸ヤ綔,鏈尮閰嶅埌鍫嗗灈鏈�", wrkMast.getWrkNo());
- continue;
- }
- Integer crnNo = findCrnNoResult.getCrnNo();
-
- Integer targetStationId = commonService.findInStationId(findCrnNoResult, stationProtocol.getStationId());
- if (targetStationId == null) {
- News.taskInfo(wrkMast.getWrkNo(), "{}绔欑偣,鎼滅储鍏ュ簱绔欑偣澶辫触", stationProtocol.getStationId());
- continue;
- }
-
- StationCommand command = stationThread.getCommand(StationCommandType.MOVE, wrkMast.getWrkNo(), stationProtocol.getStationId(), targetStationId, 0);
- if(command == null){
- News.taskInfo(wrkMast.getWrkNo(), "{}宸ヤ綔,鑾峰彇杈撻�佺嚎鍛戒护澶辫触", wrkMast.getWrkNo());
- continue;
- }
-
- //鏇存柊婧愬簱浣�
- sourceLocMast.setLocSts("O");
- sourceLocMast.setModiTime(new Date());
- locMastService.updateById(sourceLocMast);
-
- //鏇存柊鐩爣搴撲綅
- locMast.setLocSts("S");
- locMast.setModiTime(new Date());
- locMastService.updateById(locMast);
-
- //鏇存柊宸ヤ綔妗ｆ暟鎹�
- wrkMast.setLocNo(locNo);
- wrkMast.setStaNo(targetStationId);
-
- if (findCrnNoResult.getCrnType().equals(SlaveType.Crn)) {
- wrkMast.setCrnNo(crnNo);
- } else if (findCrnNoResult.getCrnType().equals(SlaveType.DualCrn)) {
- wrkMast.setDualCrnNo(crnNo);
- }else {
- throw new CoolException("鏈煡璁惧绫诲瀷");
- }
-
- if (wrkMastService.updateById(wrkMast)) {
- MessageQueue.offer(SlaveType.Devp, basDevp.getDevpNo(), new Task(2, command));
- }
- } else {
- News.error("璇锋眰WMS鎺ュ彛澶辫触锛侊紒锛乺esponse锛歿}", response);
- }
- }else {
- //杩愯鍫靛锛岄噸鏂拌绠楄矾绾�
- StationCommand command = stationThread.getCommand(StationCommandType.MOVE, wrkMast.getWrkNo(), stationProtocol.getStationId(), wrkMast.getStaNo(), 0);
- if(command == null){
- News.taskInfo(wrkMast.getWrkNo(), "鑾峰彇杈撻�佺嚎鍛戒护澶辫触");
- continue;
- }
-
- MessageQueue.offer(SlaveType.Devp, basDevp.getDevpNo(), new Task(2, command));
- News.info("杈撻�佺珯鐐瑰牭濉炲悗閲嶆柊璁＄畻璺緞鍛戒护涓嬪彂鎴愬姛锛岀珯鐐瑰彿={}锛屽伐浣滃彿={}锛屽懡浠ゆ暟鎹�={}", stationProtocol.getStationId(), wrkMast.getWrkNo(), JSON.toJSONString(command));
- }
- }
- }
+ } catch (Exception e) {
+ e.printStackTrace();
}
}
//鑾峰彇杈撻�佺嚎浠诲姟鏁伴噺
public synchronized int getCurrentStationTaskCount() {
- int currentStationTaskCount = 0;
- List<BasDevp> basDevps = basDevpService.selectList(new EntityWrapper<BasDevp>());
+ return countCurrentStationTask();
+ }
+
+ // 妫�娴嬪嚭搴撴帓搴�
+ public synchronized void checkStationOutOrder() {
+ List<BasDevp> basDevps = basDevpService.list(new QueryWrapper<BasDevp>());
for (BasDevp basDevp : basDevps) {
- StationThread stationThread = (StationThread) SlaveConnection.get(SlaveType.Devp, basDevp.getId());
+ StationThread stationThread = (StationThread) SlaveConnection.get(SlaveType.Devp, basDevp.getDevpNo());
+ if (stationThread == null) {
+ continue;
+ }
+ 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) {
+ continue;
+ }
+
+ if (!stationProtocol.isAutoing()) {
+ continue;
+ }
+
+ if (!stationProtocol.isLoading()) {
+ continue;
+ }
+
+ if (stationProtocol.getTaskNo() <= 0) {
+ continue;
+ }
+
+ if (!stationProtocol.getStationId().equals(stationProtocol.getTargetStaNo())) {
+ continue;
+ }
+
+ WrkMast wrkMast = wrkMastService.selectByWorkNo(stationProtocol.getTaskNo());
+ if (wrkMast == null) {
+ continue;
+ }
+
+ if (isWatchingCircleArrival(wrkMast.getWrkNo(), stationProtocol.getStationId())) {
+ continue;
+ }
+
+ if (Cools.isEmpty(wrkMast.getBatch())) {
+ continue;
+ }
+
+ if (Cools.isEmpty(wrkMast.getBatchSeq())) {
+ continue;
+ }
+
+ List<WrkMast> batchWrkList = wrkMastService.list(new QueryWrapper<WrkMast>()
+ .notIn("wrk_sts", WrkStsType.STATION_RUN_COMPLETE.sts, WrkStsType.COMPLETE_OUTBOUND.sts)
+ .eq("batch", wrkMast.getBatch())
+ .orderBy(true, true, "batch_seq")
+ );
+ if (batchWrkList.isEmpty()) {
+ continue;
+ }
+ WrkMast firstWrkMast = batchWrkList.get(0);
+ Integer currentBatchSeq = firstWrkMast.getBatchSeq();
+
+ List<NavigateNode> initPath = navigateUtils.calcByStationId(wrkMast.getSourceStaNo(), wrkMast.getStaNo());
+
+ String commandType = "none";
+ Integer seq = getOutStationBatchSeq(initPath, stationProtocol.getStationId(), wrkMast.getBatch());
+ if (seq == null) {
+ if (currentBatchSeq.equals(wrkMast.getBatchSeq())) {
+ commandType = "toTarget";
+ }else {
+ commandType = "toCircle";
+ }
+ }else {
+ seq++;
+ if (seq.equals(wrkMast.getBatchSeq()) && currentBatchSeq.equals(wrkMast.getBatchSeq())) {
+ commandType = "toTarget";
+ }else {
+ commandType = "toCircle";
+ }
+ }
+
+ if (commandType.equals("toTarget")) {
+ StationCommand command = stationThread.getCommand(StationCommandType.MOVE, wrkMast.getWrkNo(), stationProtocol.getStationId(), wrkMast.getStaNo(), 0);
+ if (command == null) {
+ News.taskInfo(wrkMast.getWrkNo(), "鑾峰彇杈撻�佺嚎鍛戒护澶辫触");
+ continue;
+ }
+ if (!tryAcquireOutOrderDispatchLock(wrkMast.getWrkNo(), stationProtocol.getStationId())) {
+ continue;
+ }
+ clearWatchCircleCommand(wrkMast.getWrkNo());
+ MessageQueue.offer(SlaveType.Devp, stationObjModel.getDeviceNo(), new Task(2, command));
+ News.info("{}浠诲姟鐩存帴鍘荤洰鏍囩偣", wrkMast.getWrkNo());
+ } else if (commandType.equals("toCircle")) {
+ Integer circleTarget = resolveNextCircleOrderTarget(stationProtocol.getStationId(), outOrderStationIds);
+
+ if (circleTarget == null) {
+ News.taskInfo(wrkMast.getWrkNo(), "鏈壘鍒板彲鎵ц鐨勪笅涓�鎺掑簭妫�娴嬬偣锛屽綋鍓嶇珯鐐�={}", stationProtocol.getStationId());
+ continue;
+ }
+
+ StationCommand command = stationThread.getCommand(StationCommandType.MOVE, wrkMast.getWrkNo(), stationProtocol.getStationId(), circleTarget, 0);
+ if (command == null) {
+ News.taskInfo(wrkMast.getWrkNo(), "鑾峰彇杈撻�佺嚎鍛戒护澶辫触");
+ continue;
+ }
+ if (!tryAcquireOutOrderDispatchLock(wrkMast.getWrkNo(), stationProtocol.getStationId())) {
+ continue;
+ }
+ MessageQueue.offer(SlaveType.Devp, stationObjModel.getDeviceNo(), new Task(2, command));
+ saveWatchCircleCommand(wrkMast.getWrkNo(), command);
+ News.info("{}浠诲姟杩涜缁曞湀", wrkMast.getWrkNo());
+ }
+ }
+ }
+ }
+
+ // 鐩戞帶缁曞湀绔欑偣
+ public synchronized void watchCircleStation() {
+ List<BasDevp> basDevps = basDevpService.list(new QueryWrapper<BasDevp>());
+ for (BasDevp basDevp : basDevps) {
+ StationThread stationThread = (StationThread) SlaveConnection.get(SlaveType.Devp, basDevp.getDevpNo());
+ if (stationThread == null) {
+ continue;
+ }
+
+ List<Integer> outOrderList = basDevp.getOutOrderIntList();
+
+ for (StationProtocol stationProtocol : stationThread.getStatus()) {
+ if (!stationProtocol.isAutoing()) {
+ continue;
+ }
+
+ if (!stationProtocol.isLoading()) {
+ continue;
+ }
+
+ if (stationProtocol.getTaskNo() <= 0) {
+ continue;
+ }
+
+ StationCommand circleCommand = getWatchCircleCommand(stationProtocol.getTaskNo());
+ if (circleCommand == null) {
+ continue;
+ }
+ if (!stationProtocol.getStationId().equals(circleCommand.getTargetStaNo())) {
+ continue;
+ }
+
+ WrkMast wrkMast = wrkMastService.selectByWorkNo(stationProtocol.getTaskNo());
+ if (wrkMast == null) {
+ continue;
+ }
+
+ Integer moveStaNo = resolveDispatchOutOrderTarget(
+ stationProtocol.getStationId(),
+ wrkMast.getStaNo(),
+ outOrderList,
+ true
+ );
+
+ StationCommand command = stationThread.getCommand(StationCommandType.MOVE, wrkMast.getWrkNo(), stationProtocol.getStationId(), moveStaNo, 0);
+ if (command == null) {
+ News.taskInfo(wrkMast.getWrkNo(), "鑾峰彇杈撻�佺嚎鍛戒护澶辫触");
+ continue;
+ }
+ if (!tryAcquireOutOrderDispatchLock(wrkMast.getWrkNo(), stationProtocol.getStationId())) {
+ continue;
+ }
+ if (Objects.equals(moveStaNo, wrkMast.getStaNo())) {
+ clearWatchCircleCommand(wrkMast.getWrkNo());
+ } else {
+ saveWatchCircleCommand(wrkMast.getWrkNo(), command);
+ }
+ MessageQueue.offer(SlaveType.Devp, basDevp.getDevpNo(), new Task(2, command));
+ }
+ }
+ }
+
+ public List<Integer> getAllOutOrderList() {
+ List<Integer> list = new ArrayList<>();
+ List<BasDevp> basDevps = basDevpService.list(new QueryWrapper<BasDevp>());
+ for (BasDevp basDevp : basDevps) {
+ List<Integer> orderList = basDevp.getOutOrderIntList();
+ list.addAll(orderList);
+ }
+ return list;
+ }
+
+ private Integer resolveDispatchOutOrderTarget(Integer currentStationId,
+ Integer finalTargetStationId,
+ List<Integer> outOrderList,
+ boolean skipCurrentStation) {
+ if (finalTargetStationId == null) {
+ return null;
+ }
+ if (currentStationId == null || outOrderList == null || outOrderList.isEmpty()) {
+ return finalTargetStationId;
+ }
+
+ try {
+ List<NavigateNode> nodes = navigateUtils.calcByStationId(currentStationId, finalTargetStationId);
+ for (int i = nodes.size() - 1; i >= 0; i--) {
+ Integer stationId = getStationIdFromNode(nodes.get(i));
+ if (stationId == null) {
+ continue;
+ }
+ if (skipCurrentStation && currentStationId.equals(stationId)) {
+ continue;
+ }
+ if (outOrderList.contains(stationId)) {
+ return stationId;
+ }
+ }
+ } catch (Exception ignore) {}
+ return finalTargetStationId;
+ }
+
+ private Integer resolveNextCircleOrderTarget(Integer currentStationId, List<Integer> orderedOutStationList) {
+ if (currentStationId == null || orderedOutStationList == null || orderedOutStationList.size() <= 1) {
+ return null;
+ }
+
+ int startIndex = orderedOutStationList.indexOf(currentStationId);
+ int total = orderedOutStationList.size();
+ for (int offset = 1; offset < total; offset++) {
+ int candidateIndex = (startIndex + offset + total) % total;
+ Integer candidateStationId = orderedOutStationList.get(candidateIndex);
+ if (candidateStationId == null || currentStationId.equals(candidateStationId)) {
+ continue;
+ }
+ try {
+ List<NavigateNode> path = navigateUtils.calcByStationId(currentStationId, candidateStationId);
+ if (path != null && !path.isEmpty()) {
+ return candidateStationId;
+ }
+ } catch (Exception ignore) {}
+ }
+ return null;
+ }
+
+ private boolean tryAcquireOutOrderDispatchLock(Integer wrkNo, Integer stationId) {
+ if (wrkNo == null || wrkNo <= 0 || stationId == null) {
+ return true;
+ }
+ String key = RedisKeyType.STATION_OUT_ORDER_DISPATCH_LIMIT_.key + wrkNo + "_" + stationId;
+ Object lock = redisUtil.get(key);
+ if (lock != null) {
+ return false;
+ }
+ redisUtil.set(key, "lock", OUT_ORDER_DISPATCH_LIMIT_SECONDS);
+ return true;
+ }
+
+ private boolean isWatchingCircleArrival(Integer wrkNo, Integer stationId) {
+ StationCommand command = getWatchCircleCommand(wrkNo);
+ return command != null && stationId != null && stationId.equals(command.getTargetStaNo());
+ }
+
+ private StationCommand getWatchCircleCommand(Integer wrkNo) {
+ if (wrkNo == null || wrkNo <= 0) {
+ return null;
+ }
+ Object circleObj = redisUtil.get(RedisKeyType.WATCH_CIRCLE_STATION_.key + wrkNo);
+ if (circleObj == null) {
+ return null;
+ }
+ try {
+ return JSON.parseObject(circleObj.toString(), StationCommand.class);
+ } catch (Exception ignore) {
+ return null;
+ }
+ }
+
+ private void saveWatchCircleCommand(Integer wrkNo, StationCommand command) {
+ if (wrkNo == null || wrkNo <= 0 || command == null) {
+ return;
+ }
+ redisUtil.set(RedisKeyType.WATCH_CIRCLE_STATION_.key + wrkNo,
+ JSON.toJSONString(command, SerializerFeature.DisableCircularReferenceDetect), 60 * 60 * 24);
+ }
+
+ private void clearWatchCircleCommand(Integer wrkNo) {
+ if (wrkNo == null || wrkNo <= 0) {
+ return;
+ }
+ redisUtil.del(RedisKeyType.WATCH_CIRCLE_STATION_.key + wrkNo);
+ }
+
+ private void checkStationIdleRecover(BasDevp basDevp,
+ StationThread stationThread,
+ StationProtocol stationProtocol,
+ List<Integer> outOrderList) {
+ if (stationProtocol == null || stationProtocol.getTaskNo() == null || stationProtocol.getTaskNo() <= 0) {
+ return;
+ }
+ if (!Objects.equals(stationProtocol.getStationId(), stationProtocol.getTargetStaNo())) {
+ return;
+ }
+
+ StationTaskIdleTrack idleTrack = touchStationTaskIdleTrack(stationProtocol.getTaskNo(), stationProtocol.getStationId());
+ if (idleTrack == null || !idleTrack.isTimeout(STATION_IDLE_RECOVER_SECONDS)) {
+ return;
+ }
+
+ WrkMast wrkMast = wrkMastService.selectByWorkNo(stationProtocol.getTaskNo());
+ if (!canRecoverIdleStationTask(wrkMast, stationProtocol.getStationId())) {
+ return;
+ }
+
+ Object lock = redisUtil.get(RedisKeyType.CHECK_STATION_IDLE_RECOVER_LIMIT_.key + stationProtocol.getTaskNo());
+ if (lock != null) {
+ return;
+ }
+
+ if (hasFollowUpMoveCommandAfterStay(idleTrack, stationProtocol.getTaskNo(), stationProtocol.getStationId())) {
+ return;
+ }
+
+ Integer moveStaNo = resolveIdleRecoverTarget(stationProtocol, wrkMast, outOrderList);
+ if (moveStaNo == null || Objects.equals(moveStaNo, stationProtocol.getStationId())) {
+ return;
+ }
+
+ redisUtil.set(RedisKeyType.CHECK_STATION_IDLE_RECOVER_LIMIT_.key + stationProtocol.getTaskNo(), "lock", STATION_IDLE_RECOVER_LIMIT_SECONDS);
+
+ StationCommand command = stationThread.getCommand(
+ StationCommandType.MOVE,
+ wrkMast.getWrkNo(),
+ stationProtocol.getStationId(),
+ moveStaNo,
+ 0
+ );
+ if (command == null) {
+ News.taskInfo(wrkMast.getWrkNo(), "绔欑偣浠诲姟鍋滅暀瓒呮椂鍚庨噸绠楄矾寰勫け璐ワ紝褰撳墠绔欑偣={}锛岀洰鏍囩珯鐐�={}", stationProtocol.getStationId(), moveStaNo);
+ return;
+ }
+
+ MessageQueue.offer(SlaveType.Devp, basDevp.getDevpNo(), new Task(2, command));
+ saveStationTaskIdleTrack(new StationTaskIdleTrack(wrkMast.getWrkNo(), stationProtocol.getStationId(), System.currentTimeMillis()));
+ News.info("杈撻�佺珯鐐逛换鍔″仠鐣檣}绉掓湭杩愯锛屽凡閲嶆柊璁＄畻璺緞骞堕噸鍚繍琛岋紝绔欑偣鍙�={}锛岀洰鏍囩珯={}锛屽伐浣滃彿={}锛屽懡浠ゆ暟鎹�={}",
+ STATION_IDLE_RECOVER_SECONDS, stationProtocol.getStationId(), moveStaNo, wrkMast.getWrkNo(), JSON.toJSONString(command));
+ }
+
+ private boolean canRecoverIdleStationTask(WrkMast wrkMast, Integer currentStationId) {
+ if (wrkMast == null || currentStationId == null || wrkMast.getStaNo() == null) {
+ return false;
+ }
+ if (Objects.equals(currentStationId, wrkMast.getStaNo())) {
+ return false;
+ }
+ return Objects.equals(wrkMast.getWrkSts(), WrkStsType.INBOUND_DEVICE_RUN.sts)
+ || Objects.equals(wrkMast.getWrkSts(), WrkStsType.STATION_RUN.sts);
+ }
+
+ private Integer resolveIdleRecoverTarget(StationProtocol stationProtocol,
+ WrkMast wrkMast,
+ List<Integer> outOrderList) {
+ if (stationProtocol == null || wrkMast == null) {
+ return null;
+ }
+ Integer currentStationId = stationProtocol.getStationId();
+ if (currentStationId == null) {
+ return null;
+ }
+ if (Objects.equals(wrkMast.getWrkSts(), WrkStsType.STATION_RUN.sts)) {
+ return resolveDispatchOutOrderTarget(currentStationId, wrkMast.getStaNo(), outOrderList, true);
+ }
+ return wrkMast.getStaNo();
+ }
+
+ private boolean hasFollowUpMoveCommandAfterStay(StationTaskIdleTrack idleTrack,
+ Integer taskNo,
+ Integer stationId) {
+ if (idleTrack == null || taskNo == null || stationId == null || idleTrack.firstSeenTime == null) {
+ return false;
+ }
+ if (basStationOptService == null) {
+ return false;
+ }
+
+ List<BasStationOpt> optList;
+ try {
+ optList = basStationOptService.list(new QueryWrapper<BasStationOpt>()
+ .select("id", "target_station_id")
+ .eq("task_no", taskNo)
+ .eq("source_station_id", stationId)
+ .eq("mode", String.valueOf(StationCommandType.MOVE))
+ .eq("send", 1)
+ .ge("send_time", new Date(idleTrack.firstSeenTime))
+ .orderByDesc("send_time")
+ .last("limit 3"));
+ } catch (Exception e) {
+ return false;
+ }
+
+ if (optList == null || optList.isEmpty()) {
+ return false;
+ }
+
+ for (BasStationOpt opt : optList) {
+ if (opt != null && opt.getTargetStationId() != null && !Objects.equals(opt.getTargetStationId(), stationId)) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ private StationTaskIdleTrack touchStationTaskIdleTrack(Integer taskNo, Integer stationId) {
+ if (taskNo == null || taskNo <= 0 || stationId == null) {
+ return null;
+ }
+ long now = System.currentTimeMillis();
+ StationTaskIdleTrack idleTrack = getStationTaskIdleTrack(taskNo);
+ if (idleTrack == null || !Objects.equals(idleTrack.stationId, stationId)) {
+ idleTrack = new StationTaskIdleTrack(taskNo, stationId, now);
+ saveStationTaskIdleTrack(idleTrack);
+ }
+ return idleTrack;
+ }
+
+ private StationTaskIdleTrack getStationTaskIdleTrack(Integer taskNo) {
+ if (taskNo == null || taskNo <= 0) {
+ return null;
+ }
+ Object obj = redisUtil.get(RedisKeyType.STATION_TASK_IDLE_TRACK_.key + taskNo);
+ if (obj == null) {
+ return null;
+ }
+ try {
+ return JSON.parseObject(obj.toString(), StationTaskIdleTrack.class);
+ } catch (Exception e) {
+ return null;
+ }
+ }
+
+ private void saveStationTaskIdleTrack(StationTaskIdleTrack idleTrack) {
+ if (idleTrack == null || idleTrack.taskNo == null || idleTrack.taskNo <= 0) {
+ return;
+ }
+ redisUtil.set(
+ RedisKeyType.STATION_TASK_IDLE_TRACK_.key + idleTrack.taskNo,
+ JSON.toJSONString(idleTrack, SerializerFeature.DisableCircularReferenceDetect),
+ STATION_IDLE_TRACK_EXPIRE_SECONDS
+ );
+ }
+
+ public Integer getOutStationBatchSeq(List<NavigateNode> pathList, Integer searchStationId, String searchBatch) {
+ List<Integer> checkList = new ArrayList<>();
+ for (int i = pathList.size() - 1; i >= 0; i--) {
+ NavigateNode node = pathList.get(i);
+ JSONObject v = JSONObject.parseObject(node.getNodeValue());
+ if (v != null) {
+ Integer stationId = v.getInteger("stationId");
+ if (searchStationId.equals(stationId)) {
+ break;
+ } else {
+ checkList.add(stationId);
+ }
+ }
+ }
+
+ HashMap<String, Integer> batchMap = new HashMap<>();
+ for (Integer station : checkList) {
+ BasStation basStation = basStationService.getOne(new QueryWrapper<BasStation>().eq("station_id", station));
+ if (basStation == null) {
+ continue;
+ }
+
+ StationThread stationThread = (StationThread) SlaveConnection.get(SlaveType.Devp, basStation.getDeviceNo());
+ if (stationThread == null) {
+ continue;
+ }
+ Map<Integer, StationProtocol> statusMap = stationThread.getStatusMap();
+ StationProtocol checkStationProtocol = statusMap.get(station);
+ if (checkStationProtocol == null) {
+ continue;
+ }
+ if (checkStationProtocol.getTaskNo() > 0) {
+ WrkMast checkWrkMast = wrkMastService.selectByWorkNo(checkStationProtocol.getTaskNo());
+ if (checkWrkMast == null) {
+ continue;
+ }
+
+ if (!Cools.isEmpty(checkWrkMast.getBatch())) {
+ batchMap.put(checkWrkMast.getBatch(), checkWrkMast.getBatchSeq());
+ }
+ }
+ }
+
+ Integer seq = batchMap.get(searchBatch);
+ return seq;
+ }
+
+ private int countCurrentStationTask() {
+ int currentStationTaskCount = 0;
+ List<BasDevp> basDevps = basDevpService.list(new QueryWrapper<BasDevp>());
+ for (BasDevp basDevp : basDevps) {
+ StationThread stationThread = (StationThread) SlaveConnection.get(SlaveType.Devp, basDevp.getDevpNo());
if (stationThread == null) {
continue;
}
@@ -371,9 +1067,345 @@
}
}
}
-
return currentStationTaskCount;
}
+ private boolean isDispatchBlocked(DispatchLimitConfig config,
+ int currentStationTaskCount,
+ LoadGuardState loadGuardState,
+ boolean needReserveLoopLoad) {
+ if (config.loopModeEnable) {
+ double currentLoad = loadGuardState.currentLoad();
+ if (currentLoad >= config.circleMaxLoadLimit) {
+ News.warn("褰撳墠鎵胯浇閲忚揪鍒颁笂闄愶紝宸插仠姝㈢珯鐐逛换鍔′笅鍙戙�傚綋鍓嶆壙杞介噺={}锛屼笂闄�={}", formatPercent(currentLoad), formatPercent(config.circleMaxLoadLimit));
+ return true;
+ }
+
+ if (needReserveLoopLoad) {
+ double reserveLoad = loadGuardState.loadAfterReserve();
+ if (reserveLoad >= config.circleMaxLoadLimit) {
+ News.warn("棰勫崰鍚庢壙杞介噺杈惧埌涓婇檺锛屽凡鍋滄绔欑偣浠诲姟涓嬪彂銆傞鍗犲悗鎵胯浇閲�={}锛屼笂闄�={}", formatPercent(reserveLoad), formatPercent(config.circleMaxLoadLimit));
+ return true;
+ }
+ }
+ }
+ return false;
+ }
+
+ private LoadGuardState buildLoadGuardState(DispatchLimitConfig config) {
+ LoadGuardState state = new LoadGuardState();
+ if (!config.loopModeEnable) {
+ return state;
+ }
+
+ StationCycleCapacityVo capacityVo = stationCycleCapacityService.getLatestSnapshot();
+ if (capacityVo == null) {
+ return state;
+ }
+
+ state.totalStationCount = toNonNegative(capacityVo.getTotalStationCount());
+ Integer occupiedStationCount = capacityVo.getOccupiedStationCount();
+ state.projectedTaskStationCount = toNonNegative(occupiedStationCount != null ? occupiedStationCount : capacityVo.getTaskStationCount());
+
+ List<StationCycleLoopVo> loopList = capacityVo.getLoopList();
+ if (loopList != null) {
+ for (StationCycleLoopVo loopVo : loopList) {
+ if (loopVo == null || loopVo.getStationIdList() == null) {
+ continue;
+ }
+ Integer loopNo = loopVo.getLoopNo();
+ for (Integer stationId : loopVo.getStationIdList()) {
+ if (stationId != null) {
+ if (loopNo != null) {
+ state.stationLoopNoMap.put(stationId, loopNo);
+ }
+ }
+ }
+ }
+ }
+ return state;
+ }
+
+ private LoopHitResult findPathLoopHit(DispatchLimitConfig config,
+ Integer sourceStationId,
+ Integer targetStationId,
+ LoadGuardState loadGuardState) {
+ if (!config.loopModeEnable) {
+ return LoopHitResult.NO_HIT;
+ }
+ if (sourceStationId == null || targetStationId == null) {
+ return LoopHitResult.NO_HIT;
+ }
+ if (loadGuardState.stationLoopNoMap.isEmpty()) {
+ return LoopHitResult.NO_HIT;
+ }
+
+ try {
+ List<NavigateNode> nodes = navigateUtils.calcByStationId(sourceStationId, targetStationId);
+ if (nodes == null || nodes.isEmpty()) {
+ return LoopHitResult.NO_HIT;
+ }
+
+ for (NavigateNode node : nodes) {
+ Integer stationId = getStationIdFromNode(node);
+ if (stationId == null) {
+ continue;
+ }
+ Integer loopNo = loadGuardState.stationLoopNoMap.get(stationId);
+ if (loopNo != null) {
+ return new LoopHitResult(true, loopNo, stationId);
+ }
+ }
+ } catch (Exception e) {
+ return LoopHitResult.NO_HIT;
+ }
+
+ return LoopHitResult.NO_HIT;
+ }
+
+ private Integer getStationIdFromNode(NavigateNode node) {
+ if (node == null || isBlank(node.getNodeValue())) {
+ return null;
+ }
+ try {
+ JSONObject v = JSONObject.parseObject(node.getNodeValue());
+ if (v == null) {
+ return null;
+ }
+ return v.getInteger("stationId");
+ } catch (Exception e) {
+ return null;
+ }
+ }
+
+ private int toNonNegative(Integer value) {
+ if (value == null || value < 0) {
+ return 0;
+ }
+ return value;
+ }
+
+ private void saveLoopLoadReserve(Integer wrkNo, LoopHitResult loopHitResult) {
+ if (wrkNo == null || wrkNo <= 0 || loopHitResult == null || !loopHitResult.isThroughLoop()) {
+ return;
+ }
+ JSONObject reserveJson = new JSONObject();
+ reserveJson.put("wrkNo", wrkNo);
+ reserveJson.put("loopNo", loopHitResult.getLoopNo());
+ reserveJson.put("hitStationId", loopHitResult.getHitStationId());
+ reserveJson.put("createTime", System.currentTimeMillis());
+ redisUtil.hset(RedisKeyType.STATION_CYCLE_LOAD_RESERVE.key, String.valueOf(wrkNo), reserveJson.toJSONString());
+ redisUtil.expire(RedisKeyType.STATION_CYCLE_LOAD_RESERVE.key, LOOP_LOAD_RESERVE_EXPIRE_SECONDS);
+ }
+
+ private DispatchLimitConfig getDispatchLimitConfig(Integer startStationId, Integer endStationId) {
+ DispatchLimitConfig config = new DispatchLimitConfig();
+ Object systemConfigMapObj = redisUtil.get(RedisKeyType.SYSTEM_CONFIG_MAP.key);
+ if (systemConfigMapObj instanceof Map) {
+ Map<?, ?> systemConfigMap = (Map<?, ?>) systemConfigMapObj;
+ config.circleMaxLoadLimit = parseLoadLimit(getConfigValue(systemConfigMap, "circleMaxLoadLimit"), config.circleMaxLoadLimit);
+ String loopModeValue = getConfigValue(systemConfigMap, "circleLoopModeEnable");
+ if (isBlank(loopModeValue)) {
+ loopModeValue = getConfigValue(systemConfigMap, "circleModeEnable");
+ }
+ if (isBlank(loopModeValue)) {
+ loopModeValue = getConfigValue(systemConfigMap, "isCircleMode");
+ }
+ config.loopModeEnable = parseBoolean(loopModeValue, config.loopModeEnable);
+ }
+
+ if (stationPathPolicyService != null && startStationId != null && endStationId != null) {
+ try {
+ StationPathResolvedPolicy resolvedPolicy = stationPathPolicyService.resolvePolicy(startStationId, endStationId);
+ if (resolvedPolicy != null && resolvedPolicy.getProfileConfig() != null) {
+ config.circleMaxLoadLimit = parseLoadLimit(String.valueOf(resolvedPolicy.getProfileConfig().getCircleMaxLoadLimit()), config.circleMaxLoadLimit);
+ }
+ } catch (Exception ignore) {
+ }
+ }
+
+ return config;
+ }
+
+ private String getConfigValue(Map<?, ?> configMap, String key) {
+ Object value = configMap.get(key);
+ if (value == null) {
+ return null;
+ }
+ return String.valueOf(value).trim();
+ }
+
+ private boolean parseBoolean(String value, boolean defaultValue) {
+ if (isBlank(value)) {
+ return defaultValue;
+ }
+ String lowValue = value.toLowerCase(Locale.ROOT);
+ if ("y".equals(lowValue) || "yes".equals(lowValue) || "true".equals(lowValue)
+ || "1".equals(lowValue) || "on".equals(lowValue)) {
+ return true;
+ }
+ if ("n".equals(lowValue) || "no".equals(lowValue) || "false".equals(lowValue)
+ || "0".equals(lowValue) || "off".equals(lowValue)) {
+ return false;
+ }
+ return defaultValue;
+ }
+
+ private double parseLoadLimit(String value, double defaultValue) {
+ if (isBlank(value)) {
+ return defaultValue;
+ }
+ try {
+ String normalized = value.replace("%", "").trim();
+ double parsed = Double.parseDouble(normalized);
+ if (parsed > 1.0) {
+ parsed = parsed / 100.0;
+ }
+ if (parsed < 0.0) {
+ return 0.0;
+ }
+ if (parsed > 1.0) {
+ return 1.0;
+ }
+ return parsed;
+ } catch (Exception e) {
+ return defaultValue;
+ }
+ }
+
+ private int parseInt(String value, int defaultValue) {
+ if (isBlank(value)) {
+ return defaultValue;
+ }
+ try {
+ int parsed = Integer.parseInt(value.trim());
+ return parsed < 0 ? defaultValue : parsed;
+ } catch (Exception e) {
+ return defaultValue;
+ }
+ }
+
+ private String formatPercent(double value) {
+ return String.format(Locale.ROOT, "%.1f%%", value * 100.0);
+ }
+
+ private boolean isBlank(String value) {
+ return value == null || value.trim().isEmpty();
+ }
+
+ private static class DispatchLimitConfig {
+ // 鍦堟渶澶ф壙杞借兘鍔涳紝榛樿80%
+ private double circleMaxLoadLimit = 0.8d;
+ // 鏄惁鍚敤缁曞湀妯″紡锛堜粎鍚敤鏃舵墠鐢熸晥鎵胯浇闄愬埗锛�
+ private boolean loopModeEnable = false;
+ }
+
+ private static class LoadGuardState {
+ private int totalStationCount = 0;
+ private int projectedTaskStationCount = 0;
+ private final Map<Integer, Integer> stationLoopNoMap = new HashMap<>();
+
+ private double currentLoad() {
+ return calcLoad(this.projectedTaskStationCount, this.totalStationCount);
+ }
+
+ private double loadAfterReserve() {
+ return calcLoad(this.projectedTaskStationCount + 1, this.totalStationCount);
+ }
+
+ private void reserveLoopTask(Integer loopNo) {
+ if (loopNo == null || loopNo <= 0) {
+ return;
+ }
+ if (this.totalStationCount <= 0) {
+ return;
+ }
+ this.projectedTaskStationCount++;
+ }
+
+ private double calcLoad(int taskCount, int stationCount) {
+ if (stationCount <= 0 || taskCount <= 0) {
+ return 0.0;
+ }
+ double load = (double) taskCount / (double) stationCount;
+ if (load < 0.0) {
+ return 0.0;
+ }
+ if (load > 1.0) {
+ return 1.0;
+ }
+ return load;
+ }
+ }
+
+ private static class LoopHitResult {
+ private static final LoopHitResult NO_HIT = new LoopHitResult(false, null, null);
+ private final boolean throughLoop;
+ private final Integer loopNo;
+ private final Integer hitStationId;
+
+ private LoopHitResult(boolean throughLoop, Integer loopNo, Integer hitStationId) {
+ this.throughLoop = throughLoop;
+ this.loopNo = loopNo;
+ this.hitStationId = hitStationId;
+ }
+
+ private boolean isThroughLoop() {
+ return throughLoop;
+ }
+
+ private Integer getLoopNo() {
+ return loopNo;
+ }
+
+ private Integer getHitStationId() {
+ return hitStationId;
+ }
+ }
+
+ private static class StationTaskIdleTrack {
+ private Integer taskNo;
+ private Integer stationId;
+ private Long firstSeenTime;
+
+ private StationTaskIdleTrack() {}
+
+ private StationTaskIdleTrack(Integer taskNo, Integer stationId, Long firstSeenTime) {
+ this.taskNo = taskNo;
+ this.stationId = stationId;
+ this.firstSeenTime = firstSeenTime;
+ }
+
+ private boolean isTimeout(int seconds) {
+ if (firstSeenTime == null) {
+ return false;
+ }
+ return System.currentTimeMillis() - firstSeenTime >= seconds * 1000L;
+ }
+
+ public Integer getTaskNo() {
+ return taskNo;
+ }
+
+ public void setTaskNo(Integer taskNo) {
+ this.taskNo = taskNo;
+ }
+
+ public Integer getStationId() {
+ return stationId;
+ }
+
+ public void setStationId(Integer stationId) {
+ this.stationId = stationId;
+ }
+
+ public Long getFirstSeenTime() {
+ return firstSeenTime;
+ }
+
+ public void setFirstSeenTime(Long firstSeenTime) {
+ this.firstSeenTime = firstSeenTime;
+ }
+ }
}
--
Gitblit v1.9.1