package com.zy.core.utils;
|
|
import com.alibaba.fastjson.JSON;
|
import com.alibaba.fastjson.JSONObject;
|
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;
|
import com.zy.core.cache.SlaveConnection;
|
import com.zy.core.enums.*;
|
import com.zy.core.model.StationObjModel;
|
import com.zy.core.model.Task;
|
import com.zy.core.model.command.StationCommand;
|
import com.zy.core.model.protocol.StationProtocol;
|
import com.zy.core.thread.StationThread;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Component;
|
|
import java.util.*;
|
|
@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;
|
private static final long STATION_MOVE_RESET_WAIT_MS = 1000L;
|
private static final String IDLE_RECOVER_CLEARED_MEMO = "idleRecoverRerouteCleared";
|
|
@Autowired
|
private BasDevpService basDevpService;
|
@Autowired
|
private WrkMastService wrkMastService;
|
@Autowired
|
private CommonService commonService;
|
@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() {
|
try {
|
DispatchLimitConfig baseLimitConfig = getDispatchLimitConfig(null, null);
|
int[] currentStationTaskCountRef = new int[]{countCurrentStationTask()};
|
LoadGuardState loadGuardState = 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> 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_OUT_EXECUTE_LIMIT.key + stationProtocol.getStationId());
|
if (lock != null) {
|
continue;
|
}
|
|
//满足自动、有物、工作号0
|
if (stationProtocol.isAutoing()
|
&& stationProtocol.isLoading()
|
&& stationProtocol.getTaskNo() == 0
|
) {
|
OutOrderDispatchDecision dispatchDecision = resolveOutboundDispatchDecision(
|
stationProtocol.getStationId(),
|
wrkMast,
|
outOrderList
|
);
|
Integer moveStaNo = dispatchDecision == null ? null : dispatchDecision.getTargetStationId();
|
if (moveStaNo == null) {
|
continue;
|
}
|
|
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;
|
}
|
|
wrkMast.setWrkSts(WrkStsType.STATION_RUN.sts);
|
wrkMast.setSystemMsg("");
|
wrkMast.setIoTime(new Date());
|
if (wrkMastService.updateById(wrkMast)) {
|
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 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;
|
}
|
|
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_OUT_EXECUTE_LIMIT.key + stationProtocol.getStationId());
|
if (lock != null) {
|
continue;
|
}
|
|
//满足自动、有物、工作号0
|
if (stationProtocol.isAutoing()
|
&& stationProtocol.isLoading()
|
&& stationProtocol.getTaskNo() == 0
|
) {
|
StationCommand command = stationThread.getCommand(StationCommandType.MOVE, wrkMast.getWrkNo(), stationProtocol.getStationId(), wrkMast.getStaNo(), 0);
|
if (command == null) {
|
News.taskInfo(wrkMast.getWrkNo(), "获取输送线命令失败");
|
continue;
|
}
|
|
wrkMast.setWrkSts(WrkStsType.STATION_RUN.sts);
|
wrkMast.setSystemMsg("");
|
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.del(RedisKeyType.DUAL_CRN_OUT_TASK_STATION_INFO.key + wrkMast.getWrkNo());
|
}
|
}
|
}
|
} catch (Exception e) {
|
e.printStackTrace();
|
}
|
}
|
|
//检测输送站点出库任务执行完成
|
public synchronized void stationOutExecuteFinish() {
|
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();
|
|
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();
|
}
|
}
|
|
// 检测任务转完成
|
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<Integer> outOrderStationIds = basDevp.getOutOrderIntList();
|
|
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重新分配库位接口失败，接口未响应！！！response：{}", 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接口失败！！！response：{}", response);
|
}
|
} else {
|
//运行堵塞，重新计算路线
|
OutOrderDispatchDecision dispatchDecision = resolveOutboundDispatchDecision(
|
stationProtocol.getStationId(),
|
wrkMast,
|
outOrderStationIds
|
);
|
Integer moveStaNo = dispatchDecision == null ? null : dispatchDecision.getTargetStationId();
|
if (moveStaNo == null || Objects.equals(moveStaNo, stationProtocol.getStationId())) {
|
continue;
|
}
|
|
StationCommand command = stationThread.getRunBlockRerouteCommand(
|
wrkMast.getWrkNo(),
|
stationProtocol.getStationId(),
|
moveStaNo,
|
0
|
);
|
if (command == null) {
|
News.taskInfo(wrkMast.getWrkNo(),
|
"输送站点堵塞重规划未找到可下发路线，当前站点={}，目标站点={}",
|
stationProtocol.getStationId(),
|
moveStaNo);
|
continue;
|
}
|
|
MessageQueue.offer(SlaveType.Devp, basDevp.getDevpNo(), new Task(2, command));
|
syncOutOrderWatchState(wrkMast, stationProtocol.getStationId(), outOrderStationIds, dispatchDecision, 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<>());
|
for (BasDevp basDevp : basDevps) {
|
StationThread stationThread = (StationThread) SlaveConnection.get(SlaveType.Devp, basDevp.getDevpNo());
|
if (stationThread == null) {
|
continue;
|
}
|
|
List<StationProtocol> list = stationThread.getStatus();
|
for (StationProtocol stationProtocol : list) {
|
if (stationProtocol.isAutoing()
|
&& stationProtocol.isLoading()
|
&& stationProtocol.getTaskNo() > 0
|
&& !stationProtocol.isRunBlock()
|
) {
|
checkStationIdleRecover(basDevp, stationThread, stationProtocol, basDevp.getOutOrderIntList());
|
}
|
}
|
}
|
} catch (Exception e) {
|
e.printStackTrace();
|
}
|
}
|
|
//获取输送线任务数量
|
public synchronized int getCurrentStationTaskCount() {
|
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.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 (!Objects.equals(wrkMast.getWrkSts(), WrkStsType.STATION_RUN.sts)) {
|
continue;
|
}
|
if (Objects.equals(stationProtocol.getStationId(), wrkMast.getStaNo())) {
|
continue;
|
}
|
|
if (isWatchingCircleArrival(wrkMast.getWrkNo(), stationProtocol.getStationId())) {
|
continue;
|
}
|
|
OutOrderDispatchDecision dispatchDecision = resolveOutboundDispatchDecision(
|
stationProtocol.getStationId(),
|
wrkMast,
|
outOrderStationIds
|
);
|
Integer moveStaNo = dispatchDecision == null ? null : dispatchDecision.getTargetStationId();
|
if (moveStaNo == null || Objects.equals(moveStaNo, stationProtocol.getStationId())) {
|
continue;
|
}
|
|
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;
|
}
|
syncOutOrderWatchState(wrkMast, stationProtocol.getStationId(), outOrderStationIds, dispatchDecision, command);
|
MessageQueue.offer(SlaveType.Devp, stationObjModel.getDeviceNo(), new Task(2, command));
|
News.info(dispatchDecision.isCircle() ? "{}任务进行绕圈" : "{}任务直接去目标点", 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;
|
}
|
if (!Objects.equals(wrkMast.getWrkSts(), WrkStsType.STATION_RUN.sts)) {
|
continue;
|
}
|
if (Objects.equals(stationProtocol.getStationId(), wrkMast.getStaNo())) {
|
continue;
|
}
|
|
OutOrderDispatchDecision dispatchDecision = resolveOutboundDispatchDecision(
|
stationProtocol.getStationId(),
|
wrkMast,
|
outOrderList
|
);
|
Integer moveStaNo = dispatchDecision == null ? null : dispatchDecision.getTargetStationId();
|
if (moveStaNo == null || Objects.equals(moveStaNo, stationProtocol.getStationId())) {
|
continue;
|
}
|
|
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;
|
}
|
syncOutOrderWatchState(wrkMast, stationProtocol.getStationId(), outOrderList, dispatchDecision, 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 OutOrderDispatchDecision resolveOutboundDispatchDecision(Integer currentStationId,
|
WrkMast wrkMast,
|
List<Integer> outOrderStationIds) {
|
if (wrkMast == null || wrkMast.getStaNo() == null) {
|
return null;
|
}
|
if (!shouldApplyOutOrder(wrkMast, outOrderStationIds)) {
|
return new OutOrderDispatchDecision(wrkMast.getStaNo(), false);
|
}
|
Integer dispatchStationId = resolveDispatchOutOrderTarget(
|
wrkMast.getSourceStaNo(),
|
wrkMast.getStaNo(),
|
outOrderStationIds
|
);
|
if (dispatchStationId == null) {
|
return null;
|
}
|
if (isCurrentOutOrderDispatchStation(currentStationId, wrkMast, outOrderStationIds)) {
|
return resolveCurrentOutOrderDispatchDecision(currentStationId, wrkMast, outOrderStationIds);
|
}
|
if (!Objects.equals(dispatchStationId, wrkMast.getStaNo())
|
&& isCurrentOutOrderStation(currentStationId, outOrderStationIds)
|
&& isWatchingCircleArrival(wrkMast.getWrkNo(), currentStationId)) {
|
Integer circleTarget = resolveNextCircleOrderTarget(currentStationId, outOrderStationIds);
|
if (circleTarget == null) {
|
return null;
|
}
|
return new OutOrderDispatchDecision(circleTarget, true);
|
}
|
return new OutOrderDispatchDecision(dispatchStationId, false);
|
}
|
|
private OutOrderDispatchDecision resolveCurrentOutOrderDispatchDecision(Integer currentStationId,
|
WrkMast wrkMast,
|
List<Integer> outOrderStationIds) {
|
if (!isCurrentOutOrderDispatchStation(currentStationId, wrkMast, outOrderStationIds)) {
|
return null;
|
}
|
|
List<WrkMast> batchWrkList = wrkMastService.list(new QueryWrapper<WrkMast>()
|
.eq("io_type", WrkIoType.OUT.id)
|
.notIn("wrk_sts",
|
WrkStsType.STATION_RUN_COMPLETE.sts,
|
WrkStsType.COMPLETE_OUTBOUND.sts,
|
WrkStsType.SETTLE_OUTBOUND.sts)
|
.eq("batch", wrkMast.getBatch())
|
.orderByAsc("batch_seq")
|
.orderByAsc("wrk_no"));
|
if (batchWrkList.isEmpty()) {
|
return new OutOrderDispatchDecision(wrkMast.getStaNo(), false);
|
}
|
|
WrkMast firstWrkMast = batchWrkList.get(0);
|
Integer currentBatchSeq = firstWrkMast.getBatchSeq();
|
if (currentBatchSeq == null) {
|
News.taskInfo(wrkMast.getWrkNo(), "批次:{} 首个未完成任务缺少批次序号，当前任务暂不放行", wrkMast.getBatch());
|
return null;
|
}
|
|
List<NavigateNode> initPath;
|
try {
|
initPath = navigateUtils.calcByStationId(wrkMast.getSourceStaNo(), wrkMast.getStaNo());
|
} catch (Exception e) {
|
News.taskInfo(wrkMast.getWrkNo(), "批次:{} 计算排序路径失败，当前站点={}", wrkMast.getBatch(), currentStationId);
|
return null;
|
}
|
|
Integer seq = getOutStationBatchSeq(initPath, currentStationId, wrkMast.getBatch());
|
boolean toTarget;
|
if (seq == null) {
|
toTarget = currentBatchSeq.equals(wrkMast.getBatchSeq());
|
} else {
|
toTarget = Integer.valueOf(seq + 1).equals(wrkMast.getBatchSeq())
|
&& currentBatchSeq.equals(wrkMast.getBatchSeq());
|
}
|
if (toTarget) {
|
if (hasReachableOutReleaseSlot(currentStationId, wrkMast.getStaNo())) {
|
return new OutOrderDispatchDecision(wrkMast.getStaNo(), false);
|
}
|
Integer circleTarget = resolveNextCircleOrderTarget(currentStationId, outOrderStationIds);
|
if (circleTarget == null) {
|
News.taskInfo(wrkMast.getWrkNo(), "目标站当前不可进，且未找到可执行的下一排序检测点，当前站点={}", currentStationId);
|
return null;
|
}
|
return new OutOrderDispatchDecision(circleTarget, true);
|
}
|
|
Integer circleTarget = resolveNextCircleOrderTarget(currentStationId, outOrderStationIds);
|
if (circleTarget == null) {
|
News.taskInfo(wrkMast.getWrkNo(), "未找到可执行的下一排序检测点，当前站点={}", currentStationId);
|
return null;
|
}
|
return new OutOrderDispatchDecision(circleTarget, true);
|
}
|
|
private boolean shouldApplyOutOrder(WrkMast wrkMast, List<Integer> outOrderStationIds) {
|
return wrkMast != null
|
&& wrkMast.getStaNo() != null
|
&& Objects.equals(wrkMast.getIoType(), WrkIoType.OUT.id)
|
&& !Cools.isEmpty(wrkMast.getBatch())
|
&& wrkMast.getBatchSeq() != null
|
&& outOrderStationIds != null
|
&& !outOrderStationIds.isEmpty();
|
}
|
|
private boolean isCurrentOutOrderDispatchStation(Integer currentStationId,
|
WrkMast wrkMast,
|
List<Integer> outOrderStationIds) {
|
if (!shouldApplyOutOrder(wrkMast, outOrderStationIds) || currentStationId == null) {
|
return false;
|
}
|
Integer dispatchStationId = resolveDispatchOutOrderTarget(
|
wrkMast.getSourceStaNo(),
|
wrkMast.getStaNo(),
|
outOrderStationIds
|
);
|
return dispatchStationId != null
|
&& !Objects.equals(dispatchStationId, wrkMast.getStaNo())
|
&& Objects.equals(currentStationId, dispatchStationId);
|
}
|
|
private boolean isCurrentOutOrderStation(Integer currentStationId,
|
List<Integer> outOrderStationIds) {
|
return currentStationId != null
|
&& outOrderStationIds != null
|
&& outOrderStationIds.contains(currentStationId);
|
}
|
|
private void syncOutOrderWatchState(WrkMast wrkMast,
|
Integer currentStationId,
|
List<Integer> outOrderStationIds,
|
OutOrderDispatchDecision dispatchDecision,
|
StationCommand command) {
|
if (dispatchDecision == null || command == null || !shouldApplyOutOrder(wrkMast, outOrderStationIds)) {
|
return;
|
}
|
if (dispatchDecision.isCircle()) {
|
saveWatchCircleCommand(wrkMast.getWrkNo(), command);
|
} else {
|
clearWatchCircleCommand(wrkMast.getWrkNo());
|
}
|
}
|
|
private Integer resolveDispatchOutOrderTarget(Integer sourceStationId,
|
Integer finalTargetStationId,
|
List<Integer> outOrderList) {
|
if (finalTargetStationId == null) {
|
return null;
|
}
|
if (sourceStationId == null || outOrderList == null || outOrderList.isEmpty()) {
|
return finalTargetStationId;
|
}
|
|
try {
|
List<NavigateNode> nodes = navigateUtils.calcByStationId(sourceStationId, finalTargetStationId);
|
for (int i = nodes.size() - 1; i >= 0; i--) {
|
Integer stationId = getStationIdFromNode(nodes.get(i));
|
if (stationId == null) {
|
continue;
|
}
|
if (Objects.equals(stationId, finalTargetStationId)) {
|
continue;
|
}
|
if (outOrderList.contains(stationId)) {
|
return stationId;
|
}
|
}
|
} catch (Exception ignore) {}
|
return finalTargetStationId;
|
}
|
|
private boolean hasReachableOutReleaseSlot(Integer currentStationId,
|
Integer finalTargetStationId) {
|
if (currentStationId == null || finalTargetStationId == null) {
|
return true;
|
}
|
|
try {
|
List<NavigateNode> nodes = navigateUtils.calcByStationId(currentStationId, finalTargetStationId);
|
if (nodes == null || nodes.isEmpty()) {
|
return true;
|
}
|
|
for (NavigateNode node : nodes) {
|
Integer stationId = getStationIdFromNode(node);
|
if (stationId == null || Objects.equals(stationId, currentStationId)) {
|
continue;
|
}
|
|
if (!isPathStationBlocked(stationId)) {
|
return true;
|
}
|
}
|
return false;
|
} catch (Exception ignore) {
|
return true;
|
}
|
}
|
|
private boolean isPathStationBlocked(Integer stationId) {
|
if (stationId == null) {
|
return true;
|
}
|
|
BasStation basStation = basStationService.getOne(new QueryWrapper<BasStation>().eq("station_id", stationId));
|
if (basStation == null) {
|
return true;
|
}
|
|
StationThread stationThread = (StationThread) SlaveConnection.get(SlaveType.Devp, basStation.getDeviceNo());
|
if (stationThread == null) {
|
return true;
|
}
|
|
StationProtocol stationProtocol = stationThread.getStatusMap().get(stationId);
|
if (stationProtocol == null) {
|
return true;
|
}
|
|
return !stationProtocol.isAutoing()
|
|| stationProtocol.isLoading()
|
|| (stationProtocol.getTaskNo() != null && stationProtocol.getTaskNo() > 0);
|
}
|
|
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;
|
}
|
|
OutOrderDispatchDecision dispatchDecision = null;
|
Integer moveStaNo;
|
if (Objects.equals(wrkMast.getWrkSts(), WrkStsType.STATION_RUN.sts)) {
|
dispatchDecision = resolveOutboundDispatchDecision(stationProtocol.getStationId(), wrkMast, outOrderList);
|
moveStaNo = dispatchDecision == null ? null : dispatchDecision.getTargetStationId();
|
} else {
|
moveStaNo = wrkMast.getStaNo();
|
}
|
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);
|
resetSegmentMoveCommandsBeforeReroute(stationProtocol.getTaskNo());
|
int clearedCommandCount = clearIssuedMoveCommandsDuringIdleStay(idleTrack, stationProtocol.getTaskNo(), stationProtocol.getStationId());
|
|
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));
|
syncOutOrderWatchState(wrkMast, stationProtocol.getStationId(), outOrderList, dispatchDecision, command);
|
saveStationTaskIdleTrack(new StationTaskIdleTrack(wrkMast.getWrkNo(), stationProtocol.getStationId(), System.currentTimeMillis()));
|
News.info("输送站点任务停留{}秒未运行，已重新计算路径并重启运行，站点号={}，目标站={}，工作号={}，清理旧分段命令数={}，命令数据={}",
|
STATION_IDLE_RECOVER_SECONDS, stationProtocol.getStationId(), moveStaNo, wrkMast.getWrkNo(), clearedCommandCount, 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 void resetSegmentMoveCommandsBeforeReroute(Integer taskNo) {
|
if (redisUtil == null || taskNo == null || taskNo <= 0) {
|
return;
|
}
|
String key = RedisKeyType.DEVICE_STATION_MOVE_RESET.key + taskNo;
|
redisUtil.set(key, "cancel", 3);
|
try {
|
Thread.sleep(STATION_MOVE_RESET_WAIT_MS);
|
} catch (InterruptedException e) {
|
Thread.currentThread().interrupt();
|
} catch (Exception ignore) {
|
}
|
redisUtil.del(key);
|
}
|
|
private int clearIssuedMoveCommandsDuringIdleStay(StationTaskIdleTrack idleTrack,
|
Integer taskNo,
|
Integer stationId) {
|
if (basStationOptService == null) {
|
return 0;
|
}
|
List<BasStationOpt> optList;
|
try {
|
optList = listIssuedMoveCommandsDuringIdleStay(idleTrack, taskNo);
|
} catch (Exception e) {
|
return 0;
|
}
|
if (optList == null || optList.isEmpty()) {
|
return 0;
|
}
|
|
Date now = new Date();
|
String cleanupMemo = buildIdleRecoverClearedMemo(stationId);
|
int clearedCount = 0;
|
for (BasStationOpt opt : optList) {
|
if (opt == null || opt.getId() == null) {
|
continue;
|
}
|
opt.setSend(0);
|
opt.setUpdateTime(now);
|
opt.setMemo(appendCleanupMemo(opt.getMemo(), cleanupMemo));
|
clearedCount++;
|
}
|
if (clearedCount > 0) {
|
basStationOptService.updateBatchById(optList);
|
}
|
return clearedCount;
|
}
|
|
private List<BasStationOpt> listIssuedMoveCommandsDuringIdleStay(StationTaskIdleTrack idleTrack,
|
Integer taskNo) {
|
if (idleTrack == null || taskNo == null || taskNo <= 0 || idleTrack.firstSeenTime == null || basStationOptService == null) {
|
return Collections.emptyList();
|
}
|
List<BasStationOpt> optList = basStationOptService.list(new QueryWrapper<BasStationOpt>()
|
.select("id", "task_no", "send_time", "target_station_id", "memo", "send")
|
.eq("task_no", taskNo)
|
.eq("mode", String.valueOf(StationCommandType.MOVE))
|
.eq("send", 1)
|
.ge("send_time", new Date(idleTrack.firstSeenTime))
|
.orderByAsc("send_time"));
|
if (optList == null || optList.isEmpty()) {
|
return Collections.emptyList();
|
}
|
return optList;
|
}
|
|
private String buildIdleRecoverClearedMemo(Integer stationId) {
|
if (stationId == null) {
|
return IDLE_RECOVER_CLEARED_MEMO;
|
}
|
return IDLE_RECOVER_CLEARED_MEMO + "(stationId=" + stationId + ")";
|
}
|
|
private String appendCleanupMemo(String memo, String cleanupMemo) {
|
if (Cools.isEmpty(cleanupMemo)) {
|
return memo;
|
}
|
if (Cools.isEmpty(memo)) {
|
return cleanupMemo;
|
}
|
if (memo.contains(cleanupMemo)) {
|
return memo;
|
}
|
return memo + " | " + cleanupMemo;
|
}
|
|
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) {
|
if (pathList == null || pathList.isEmpty() || searchStationId == null || Cools.isEmpty(searchBatch)) {
|
return null;
|
}
|
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;
|
}
|
|
for (StationProtocol stationProtocol : stationThread.getStatus()) {
|
if (stationProtocol.getTaskNo() > 0) {
|
currentStationTaskCount++;
|
}
|
}
|
}
|
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 static class OutOrderDispatchDecision {
|
private final Integer targetStationId;
|
private final boolean circle;
|
|
private OutOrderDispatchDecision(Integer targetStationId, boolean circle) {
|
this.targetStationId = targetStationId;
|
this.circle = circle;
|
}
|
|
private Integer getTargetStationId() {
|
return targetStationId;
|
}
|
|
private boolean isCircle() {
|
return circle;
|
}
|
}
|
|
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;
|
}
|
}
|
|
}
|
