package com.zy.core.plugin;
|
|
import com.alibaba.fastjson.JSON;
|
import com.alibaba.fastjson.serializer.SerializerFeature;
|
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
|
import com.core.common.Cools;
|
import com.zy.asrs.domain.param.CreateInTaskParam;
|
import com.zy.asrs.domain.param.CreateOutTaskParam;
|
import com.zy.asrs.entity.*;
|
import com.zy.asrs.service.*;
|
import com.zy.common.entity.FindCrnNoResult;
|
import com.zy.common.service.CommonService;
|
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.dispatch.StationCommandDispatcher;
|
import com.zy.core.enums.*;
|
import com.zy.core.model.StationObjModel;
|
import com.zy.core.model.Task;
|
import com.zy.core.model.command.CrnCommand;
|
import com.zy.core.model.command.StationCommand;
|
import com.zy.core.model.protocol.CrnProtocol;
|
import com.zy.core.model.protocol.DualCrnProtocol;
|
import com.zy.core.model.protocol.StationProtocol;
|
import com.zy.core.plugin.api.MainProcessPluginApi;
|
import com.zy.core.plugin.store.StoreInTaskContext;
|
import com.zy.core.plugin.store.StoreInTaskGenerationService;
|
import com.zy.core.plugin.store.StoreInTaskPolicy;
|
import com.zy.core.task.MainProcessAsyncTaskScheduler;
|
import com.zy.core.thread.CrnThread;
|
import com.zy.core.thread.DualCrnThread;
|
import com.zy.core.thread.StationThread;
|
import com.zy.core.utils.CrnOperateProcessUtils;
|
import com.zy.core.utils.DualCrnOperateProcessUtils;
|
import com.zy.core.utils.StationOperateProcessUtils;
|
import com.zy.system.entity.Config;
|
import com.zy.system.service.ConfigService;
|
import lombok.extern.slf4j.Slf4j;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Component;
|
|
import java.util.*;
|
import java.util.concurrent.ConcurrentHashMap;
|
|
@Slf4j
|
@Component
|
public class FakeProcess implements MainProcessPluginApi, StoreInTaskPolicy {
|
private static final String CRN_TASK_LANE = "fake-crn";
|
private static final String STATION_TASK_LANE = "fake-station";
|
private static final String DUAL_CRN_TASK_LANE = "fake-dual-crn";
|
private static final String GENERATE_STORE_TASK_LANE_PREFIX = "fake-generate-store-";
|
private static final String ASYNC_TASK_LANE_PREFIX = "fake-async-";
|
private static final long MAIN_DISPATCH_INTERVAL_MS = 200L;
|
private static final long ASYNC_DISPATCH_INTERVAL_MS = 50L;
|
private static final long TASK_SLOW_LOG_THRESHOLD_MS = 1000L;
|
|
private static final Map<Integer, Long> stationStayTimeMap = new ConcurrentHashMap<>();
|
private static volatile String enableFake = "N";
|
private static volatile String fakeRealTaskRequestWms = "N";
|
private static volatile String fakeGenerateInTask = "Y";
|
private static volatile String fakeGenerateOutTask = "Y";
|
|
@Autowired
|
private WrkMastService wrkMastService;
|
@Autowired
|
private BasDevpService basDevpService;
|
@Autowired
|
private ConfigService configService;
|
@Autowired
|
private LocMastService locMastService;
|
@Autowired
|
private CommonService commonService;
|
@Autowired
|
private BasCrnpService basCrnpService;
|
@Autowired
|
private BasDualCrnpService basDualCrnpService;
|
@Autowired
|
private RedisUtil redisUtil;
|
@Autowired
|
private CrnOperateProcessUtils crnOperateUtils;
|
@Autowired
|
private StationOperateProcessUtils stationOperateProcessUtils;
|
@Autowired
|
private WrkAnalysisService wrkAnalysisService;
|
@Autowired
|
private DualCrnOperateProcessUtils dualCrnOperateProcessUtils;
|
@Autowired
|
private StoreInTaskGenerationService storeInTaskGenerationService;
|
@Autowired
|
private StationCommandDispatcher stationCommandDispatcher;
|
@Autowired
|
private MainProcessAsyncTaskScheduler mainProcessAsyncTaskScheduler;
|
|
@Override
|
public void run() {
|
long startTime = System.currentTimeMillis();
|
refreshFakeConfig();
|
|
// 仿真相关任务按各自 lane 串行提交，互不阻塞
|
submitAsyncTask("checkInStationHasTask", ASYNC_DISPATCH_INTERVAL_MS, this::checkInStationHasTask);
|
submitAsyncTask("generateFakeInTask", ASYNC_DISPATCH_INTERVAL_MS, this::generateFakeInTask);
|
submitAsyncTask("generateFakeOutTask", ASYNC_DISPATCH_INTERVAL_MS, this::generateFakeOutTask);
|
submitAsyncTask("calcAllStationStayTime", ASYNC_DISPATCH_INTERVAL_MS, this::calcAllStationStayTime);
|
submitAsyncTask("checkOutStationStayTimeOut", ASYNC_DISPATCH_INTERVAL_MS, this::checkOutStationStayTimeOut);
|
submitAsyncTask("checkInStationCrnTake", ASYNC_DISPATCH_INTERVAL_MS, this::checkInStationCrnTake);
|
submitStationTask("checkStationRunBlock", ASYNC_DISPATCH_INTERVAL_MS, stationOperateProcessUtils::checkStationRunBlock);
|
|
// 请求生成入库任务，按站点拆成独立串行通道，避免单站阻塞整轮扫描
|
generateStoreWrkFile();
|
|
// 堆垛机、输送线、双工位堆垛机任务分别进入各自串行通道逐个执行
|
submitCrnTask("crnIoExecute", MAIN_DISPATCH_INTERVAL_MS, crnOperateUtils::crnIoExecute);
|
submitCrnTask("crnIoExecuteFinish", MAIN_DISPATCH_INTERVAL_MS, this::crnIoExecuteFinish);
|
submitStationTask("stationInExecute", MAIN_DISPATCH_INTERVAL_MS, stationOperateProcessUtils::stationInExecute);
|
submitStationTask("crnStationOutExecute", MAIN_DISPATCH_INTERVAL_MS, stationOperateProcessUtils::crnStationOutExecute);
|
submitStationTask("checkStationOutOrder", MAIN_DISPATCH_INTERVAL_MS, stationOperateProcessUtils::checkStationOutOrder);
|
submitStationTask("watchCircleStation", MAIN_DISPATCH_INTERVAL_MS, stationOperateProcessUtils::watchCircleStation);
|
submitDualCrnTask("dualCrnIoExecute", MAIN_DISPATCH_INTERVAL_MS, dualCrnOperateProcessUtils::dualCrnIoExecute);
|
submitDualCrnTask("dualCrnIoExecuteFinish", MAIN_DISPATCH_INTERVAL_MS, dualCrnOperateProcessUtils::dualCrnIoExecuteFinish);
|
|
News.info("[WCS Debug] 主线程Run执行完成,耗时:{}ms", System.currentTimeMillis() - startTime);
|
}
|
|
private void refreshFakeConfig() {
|
Config enableFakeConfig = configService.getOne(new QueryWrapper<Config>().eq("code", "enableFake"));
|
if (enableFakeConfig != null) {
|
enableFake = enableFakeConfig.getValue();
|
}
|
|
Config fakeRealTaskRequestWmsConfig = configService
|
.getOne(new QueryWrapper<Config>().eq("code", "fakeRealTaskRequestWms"));
|
if (fakeRealTaskRequestWmsConfig != null) {
|
fakeRealTaskRequestWms = fakeRealTaskRequestWmsConfig.getValue();
|
}
|
|
Config fakeGenerateInTaskConfig = configService
|
.getOne(new QueryWrapper<Config>().eq("code", "fakeGenerateInTask"));
|
if (fakeGenerateInTaskConfig != null) {
|
fakeGenerateInTask = fakeGenerateInTaskConfig.getValue();
|
}
|
|
Config fakeGenerateOutTaskConfig = configService
|
.getOne(new QueryWrapper<Config>().eq("code", "fakeGenerateOutTask"));
|
if (fakeGenerateOutTaskConfig != null) {
|
fakeGenerateOutTask = fakeGenerateOutTaskConfig.getValue();
|
}
|
}
|
|
private void submitCrnTask(String taskName, long minIntervalMs, Runnable task) {
|
submitProcessTask(CRN_TASK_LANE, taskName, minIntervalMs, task);
|
}
|
|
private void submitStationTask(String taskName, long minIntervalMs, Runnable task) {
|
submitProcessTask(STATION_TASK_LANE, taskName, minIntervalMs, task);
|
}
|
|
private void submitDualCrnTask(String taskName, long minIntervalMs, Runnable task) {
|
submitProcessTask(DUAL_CRN_TASK_LANE, taskName, minIntervalMs, task);
|
}
|
|
private void submitAsyncTask(String taskName, long minIntervalMs, Runnable task) {
|
submitProcessTask(ASYNC_TASK_LANE_PREFIX + taskName, taskName, minIntervalMs, task);
|
}
|
|
private void submitGenerateStoreTasks() {
|
List<BasDevp> basDevps = basDevpService.list(new QueryWrapper<>());
|
for (BasDevp basDevp : basDevps) {
|
List<StationObjModel> barcodeStations = getBarcodeStations(basDevp);
|
for (StationObjModel stationObjModel : barcodeStations) {
|
Integer stationId = stationObjModel == null ? null : stationObjModel.getStationId();
|
if (stationId == null) {
|
continue;
|
}
|
submitGenerateStoreTask(stationId, MAIN_DISPATCH_INTERVAL_MS,
|
() -> storeInTaskGenerationService.generate(this, basDevp, stationObjModel));
|
}
|
}
|
}
|
|
private void submitGenerateStoreTask(Integer stationId, long minIntervalMs, Runnable task) {
|
submitProcessTask(GENERATE_STORE_TASK_LANE_PREFIX + stationId, "generateStoreWrkFile", minIntervalMs, task);
|
}
|
|
private void submitProcessTask(String laneName, String taskName, long minIntervalMs, Runnable task) {
|
mainProcessAsyncTaskScheduler.submit(
|
laneName,
|
taskName,
|
minIntervalMs,
|
TASK_SLOW_LOG_THRESHOLD_MS,
|
task
|
);
|
}
|
|
// 检测入库站是否有任务生成，并仿真生成模拟入库站点数据
|
private void checkInStationHasTask() {
|
if (!enableFake.equals("Y")) {
|
return;
|
}
|
|
if (!fakeGenerateInTask.equals("Y")) {
|
return;
|
}
|
|
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.getInStationList$();
|
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.GENERATE_FAKE_IN_STATION_DATA_LIMIT.key + stationId);
|
if (lock != null) {
|
continue;
|
}
|
|
// 满足自动、无物、工作号0，生成入库数据
|
if (stationProtocol.isAutoing()
|
&& !stationProtocol.isLoading()
|
&& stationProtocol.getTaskNo() == 0) {
|
StationCommand command = stationThread.getCommand(StationCommandType.MOVE,
|
commonService.getWorkNo(WrkIoType.FAKE_TASK_NO.id), stationId,
|
entity.getBarcodeStation().getStationId(), 0);
|
stationCommandDispatcher.dispatch(basDevp.getDevpNo(), command, "fake-process", "fake-enable-in");
|
redisUtil.set(RedisKeyType.GENERATE_FAKE_IN_STATION_DATA_LIMIT.key + stationId, "lock", 5);
|
}
|
}
|
}
|
}
|
|
// 生成仿真模拟入库任务
|
private void generateFakeInTask() {
|
if (!enableFake.equals("Y")) {
|
return;
|
}
|
|
if (fakeRealTaskRequestWms.equals("Y")) {
|
return;
|
}
|
|
if (!fakeGenerateInTask.equals("Y")) {
|
return;
|
}
|
|
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 model : list) {
|
Integer stationId = model.getStationId();
|
if (!stationMap.containsKey(stationId)) {
|
continue;
|
}
|
|
StationProtocol stationProtocol = stationMap.get(stationId);
|
if (stationProtocol == null) {
|
continue;
|
}
|
|
Object object = redisUtil.get(RedisKeyType.GENERATE_FAKE_IN_TASK_LIMIT.key + stationId);
|
if (object != null) {
|
continue;
|
}
|
|
// 满足自动、有物、有工作号，生成入库数据
|
if (stationProtocol.isAutoing()
|
&& stationProtocol.isLoading()
|
&& stationProtocol.getTaskNo() > 0) {
|
if (Cools.isEmpty(stationProtocol.getBarcode())) {
|
continue;
|
}
|
|
// 检测任务是否生成
|
List<WrkMast> wrkMasts = wrkMastService
|
.list(new QueryWrapper<WrkMast>().eq("barcode", stationProtocol.getBarcode()));
|
if (!wrkMasts.isEmpty()) {
|
continue;
|
}
|
|
List<LocMast> locMastList = locMastService
|
.list(new QueryWrapper<LocMast>().eq("loc_sts", String.valueOf(LocStsType.O)));
|
if (locMastList.isEmpty()) {
|
continue;
|
}
|
|
int nextInt = new Random().nextInt(locMastList.size());
|
LocMast locMast = locMastList.get(nextInt);
|
|
FindCrnNoResult findCrnNoResult = commonService.findCrnNoByLocNo(locMast.getLocNo());
|
if (findCrnNoResult == null) {
|
continue;
|
}
|
|
Integer targetStationId = commonService.findInStationId(findCrnNoResult, stationId);
|
if (targetStationId == null) {
|
continue;
|
}
|
|
CreateInTaskParam taskParam = new CreateInTaskParam();
|
taskParam.setTaskNo(String.valueOf(commonService.getWorkNo(WrkIoType.IN.id)));
|
taskParam.setSourceStaNo(stationId);
|
taskParam.setStaNo(targetStationId);
|
taskParam.setLocNo(locMast.getLocNo());
|
taskParam.setBarcode(stationProtocol.getBarcode());
|
WrkMast wrkMast = commonService.createInTask(taskParam);
|
|
StationCommand command = stationThread.getCommand(StationCommandType.MOVE, wrkMast.getWrkNo(),
|
stationId, stationId, 0);
|
if (command == null) {
|
News.taskInfo(wrkMast.getWrkNo(), "获取输送线命令失败");
|
continue;
|
}
|
stationCommandDispatcher.dispatch(basDevp.getDevpNo(), command, "fake-process", "fake-in-task");
|
redisUtil.set(RedisKeyType.GENERATE_FAKE_IN_TASK_LIMIT.key + stationId, "lock", 5);
|
}
|
}
|
}
|
}
|
|
// 生成仿真模拟出库任务
|
private void generateFakeOutTask() {
|
try {
|
if (!enableFake.equals("Y")) {
|
return;
|
}
|
|
if (fakeRealTaskRequestWms.equals("Y")) {
|
return;
|
}
|
|
if (!fakeGenerateOutTask.equals("Y")) {
|
return;
|
}
|
|
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.getOutStationList$();
|
for (StationObjModel entity : list) {
|
Integer stationId = entity.getStationId();
|
if (!stationMap.containsKey(stationId)) {
|
continue;
|
}
|
|
StationProtocol stationProtocol = stationMap.get(stationId);
|
if (stationProtocol == null) {
|
continue;
|
}
|
|
Object object = redisUtil.get(RedisKeyType.GENERATE_FAKE_OUT_TASK_LIMIT.key + stationId);
|
if (object != null) {
|
return;
|
}
|
|
// 满足自动、无物、工作号0，生成出库数据
|
if (stationProtocol.isAutoing()
|
&& !stationProtocol.isLoading()
|
&& stationProtocol.getTaskNo() == 0) {
|
List<LocMast> locMastList = locMastService
|
.list(new QueryWrapper<LocMast>().eq("loc_sts", String.valueOf(LocStsType.F)));
|
if (locMastList.isEmpty()) {
|
continue;
|
}
|
|
LocMast locMast = locMastList.get(0);
|
|
CreateOutTaskParam taskParam = new CreateOutTaskParam();
|
taskParam.setTaskNo(String.valueOf(commonService.getWorkNo(WrkIoType.OUT.id)));
|
taskParam.setStaNo(stationId);
|
taskParam.setLocNo(locMast.getLocNo());
|
boolean result = commonService.createOutTask(taskParam);
|
redisUtil.set(RedisKeyType.GENERATE_FAKE_OUT_TASK_LIMIT.key + stationId, "lock", 10);
|
}
|
}
|
}
|
} catch (Exception e) {
|
log.error("generateFakeOutTask execute error", e);
|
}
|
}
|
|
/**
|
* 请求生成入库任务
|
* 入库站，根据条码扫描生成入库工作档
|
*/
|
public void generateStoreWrkFile() {
|
submitGenerateStoreTasks();
|
}
|
|
@Override
|
public boolean isEnabled() {
|
return !"N".equals(fakeRealTaskRequestWms);
|
}
|
|
@Override
|
public boolean matchCandidate(StoreInTaskContext context) {
|
StationProtocol stationProtocol = context.getStationProtocol();
|
return stationProtocol.isAutoing()
|
&& stationProtocol.isLoading()
|
&& stationProtocol.getTaskNo() > 0
|
&& !Cools.isEmpty(stationProtocol.getBarcode());
|
}
|
|
@Override
|
public void onRequestPermitGranted(StoreInTaskContext context) {
|
redisUtil.set(getGenerateLockKey(context), "lock", 3);
|
}
|
|
@Override
|
public void afterTaskCreated(StoreInTaskContext context, WrkMast wrkMast) {
|
Integer stationId = context.getStationObjModel().getStationId();
|
StationCommand command = context.getStationThread().getCommand(StationCommandType.WRITE_INFO,
|
wrkMast.getWrkNo(), stationId, stationId, 0);
|
if (command == null) {
|
News.taskInfo(wrkMast.getWrkNo(), "获取输送线命令失败");
|
return;
|
}
|
stationCommandDispatcher.dispatch(context.getBasDevp().getDevpNo(), command, "fake-process", "write-info");
|
}
|
|
// 计算所有站点停留时间
|
public void calcAllStationStayTime() {
|
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.getTaskNo() > 0
|
&& !stationStayTimeMap.containsKey(stationProtocol.getStationId())) {
|
stationStayTimeMap.put(stationProtocol.getStationId(), System.currentTimeMillis());
|
}
|
|
if (stationProtocol.getTaskNo() <= 0
|
&& stationStayTimeMap.containsKey(stationProtocol.getStationId())) {
|
stationStayTimeMap.remove(stationProtocol.getStationId());
|
}
|
}
|
}
|
}
|
|
// 检测出库站点停留是否超时
|
public void checkOutStationStayTimeOut() {
|
List<BasDevp> basDevps = basDevpService.list(new QueryWrapper<>());
|
for (BasDevp basDevp : basDevps) {
|
List<StationObjModel> outStationList = basDevp.getOutStationList$();
|
if (outStationList.isEmpty()) {
|
News.info("输送线:{} 出库站点未设置", basDevp.getDevpNo());
|
continue;
|
}
|
|
for (StationObjModel stationObjModel : outStationList) {
|
Object lock = redisUtil
|
.get(RedisKeyType.CHECK_OUT_STATION_STAY_TIME_OUT_LIMIT.key + stationObjModel.getStationId());
|
if (lock != null) {
|
continue;
|
}
|
|
Long stayTime = stationStayTimeMap.get(stationObjModel.getStationId());
|
if (stayTime == null) {
|
continue;
|
}
|
|
if (System.currentTimeMillis() - stayTime > 1000 * 60) {
|
StationThread stationThread = (StationThread) SlaveConnection.get(SlaveType.Devp,
|
stationObjModel.getDeviceNo());
|
if (stationThread == null) {
|
continue;
|
}
|
|
StationCommand command = stationThread.getCommand(StationCommandType.RESET, 0,
|
stationObjModel.getStationId(), 0, 0);
|
if (command == null) {
|
continue;
|
}
|
|
stationCommandDispatcher.dispatch(stationObjModel.getDeviceNo(), command, "fake-process", "out-station-reset");
|
redisUtil.set(
|
RedisKeyType.CHECK_OUT_STATION_STAY_TIME_OUT_LIMIT.key + stationObjModel.getStationId(),
|
"lock", 10);
|
News.info("输送站点出库重置命令下发成功，站点号={}，命令数据={}", stationObjModel.getStationId(),
|
JSON.toJSONString(command));
|
}
|
}
|
}
|
}
|
|
// 检测入库站点堆垛机是否取走货物
|
public void checkInStationCrnTake() {
|
List<BasCrnp> basCrnps = basCrnpService.list(new QueryWrapper<>());
|
for (BasCrnp basCrnp : basCrnps) {
|
List<StationObjModel> inStationList = basCrnp.getInStationList$();
|
if (inStationList.isEmpty()) {
|
News.info("堆垛机:{} 入库站点未设置", basCrnp.getCrnNo());
|
continue;
|
}
|
checkInStationListCrnTake(inStationList);
|
}
|
|
List<BasDualCrnp> basDualCrnps = basDualCrnpService.list(new QueryWrapper<>());
|
for (BasDualCrnp basDualCrnp : basDualCrnps) {
|
List<StationObjModel> inStationList = basDualCrnp.getInStationList$();
|
if (inStationList.isEmpty()) {
|
News.info("双工位堆垛机:{} 入库站点未设置", basDualCrnp.getCrnNo());
|
continue;
|
}
|
checkInStationListCrnTake(inStationList);
|
}
|
}
|
|
private void checkInStationListCrnTake(List<StationObjModel> inStationList) {
|
for (StationObjModel stationObjModel : inStationList) {
|
Object lock = redisUtil
|
.get(RedisKeyType.CHECK_IN_STATION_STAY_TIME_OUT_LIMIT.key + stationObjModel.getStationId());
|
if (lock != null) {
|
continue;
|
}
|
|
StationThread stationThread = (StationThread) SlaveConnection.get(SlaveType.Devp,
|
stationObjModel.getDeviceNo());
|
if (stationThread == null) {
|
continue;
|
}
|
|
Map<Integer, StationProtocol> statusMap = stationThread.getStatusMap();
|
StationProtocol stationProtocol = statusMap.get(stationObjModel.getStationId());
|
if (stationProtocol == null) {
|
continue;
|
}
|
|
if (stationProtocol.getTaskNo() > 0) {
|
StationCommand command = stationThread.getCommand(StationCommandType.RESET, 0,
|
stationObjModel.getStationId(), 0, 0);
|
if (command == null) {
|
continue;
|
}
|
|
WrkMast wrkMast = wrkMastService.selectByWorkNo(stationProtocol.getTaskNo());
|
if (wrkMast == null) {
|
stationCommandDispatcher.dispatch(stationObjModel.getDeviceNo(), command, "fake-process", "in-station-reset-task-over");
|
redisUtil.set(
|
RedisKeyType.CHECK_IN_STATION_STAY_TIME_OUT_LIMIT.key + stationObjModel.getStationId(),
|
"lock", 10);
|
News.info("输送站点重置命令下发成功(task_over)，站点号={}，命令数据={}", stationObjModel.getStationId(),
|
JSON.toJSONString(command));
|
} else {
|
if (wrkMast.getWrkSts() != WrkStsType.NEW_INBOUND.sts
|
&& wrkMast.getWrkSts() != WrkStsType.INBOUND_STATION_RUN.sts) {
|
Integer crnNo = wrkMast.getCrnNo();
|
if (crnNo != null) {
|
CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, crnNo);
|
if (crnThread == null) {
|
continue;
|
}
|
CrnProtocol crnProtocol = crnThread.getStatus();
|
if (!crnProtocol.getStatusType().equals(CrnStatusType.PUT_MOVING)
|
&& !crnProtocol.getStatusType().equals(CrnStatusType.PUTTING)) {
|
continue;
|
}
|
|
stationCommandDispatcher.dispatch(stationObjModel.getDeviceNo(), command, "fake-process", "in-station-reset-crn-fetch");
|
redisUtil.set(RedisKeyType.CHECK_IN_STATION_STAY_TIME_OUT_LIMIT.key
|
+ stationObjModel.getStationId(), "lock", 10);
|
News.info("输送站点重置命令下发成功(crn_fetch)，站点号={}，命令数据={}", stationObjModel.getStationId(),
|
JSON.toJSONString(command));
|
} else {
|
Integer dualCrnNo = wrkMast.getDualCrnNo();
|
DualCrnThread dualCrnThread = (DualCrnThread) SlaveConnection.get(SlaveType.DualCrn,
|
dualCrnNo);
|
if (dualCrnThread == null) {
|
continue;
|
}
|
DualCrnProtocol dualCrnProtocol = dualCrnThread.getStatus();
|
|
boolean reset = false;
|
if (dualCrnProtocol.getTaskNo() > 0 && dualCrnProtocol.getLoaded() == 1) {
|
reset = true;
|
}
|
|
if (dualCrnProtocol.getTaskNoTwo() > 0 && dualCrnProtocol.getLoadedTwo() == 1) {
|
reset = true;
|
}
|
|
if (!reset) {
|
continue;
|
}
|
|
stationCommandDispatcher.dispatch(stationObjModel.getDeviceNo(), command, "fake-process", "in-station-reset-dual-crn-fetch");
|
redisUtil.set(RedisKeyType.CHECK_IN_STATION_STAY_TIME_OUT_LIMIT.key
|
+ stationObjModel.getStationId(), "lock", 10);
|
News.info("输送站点重置命令下发成功(crn_fetch)，站点号={}，命令数据={}", stationObjModel.getStationId(),
|
JSON.toJSONString(command));
|
}
|
}
|
}
|
}
|
}
|
}
|
|
// 堆垛机任务执行完成
|
public void crnIoExecuteFinish() {
|
List<BasCrnp> basCrnps = basCrnpService.list(new QueryWrapper<>());
|
for (BasCrnp basCrnp : basCrnps) {
|
CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, basCrnp.getCrnNo());
|
if (crnThread == null) {
|
continue;
|
}
|
|
CrnProtocol crnProtocol = crnThread.getStatus();
|
if (crnProtocol == null) {
|
continue;
|
}
|
|
if (crnProtocol.getMode() == CrnModeType.AUTO.id
|
&& crnProtocol.getTaskNo() > 0
|
&& crnProtocol.getStatus() == CrnStatusType.WAITING.id) {
|
Object lock = redisUtil.get(RedisKeyType.CRN_IO_EXECUTE_FINISH_LIMIT.key + basCrnp.getCrnNo());
|
if (lock != null) {
|
continue;
|
}
|
|
// 获取待确认工作档
|
WrkMast wrkMast = wrkMastService.selectByWorkNo(crnProtocol.getTaskNo());
|
if (wrkMast == null) {
|
News.error("堆垛机处于等待确认且任务完成状态，但未找到工作档。堆垛机号={}，工作号={}", basCrnp.getCrnNo(), crnProtocol.getTaskNo());
|
continue;
|
}
|
|
Long updateWrkSts = null;
|
if (wrkMast.getWrkSts() == WrkStsType.INBOUND_RUN.sts) {
|
updateWrkSts = WrkStsType.COMPLETE_INBOUND.sts;
|
} else if (wrkMast.getWrkSts() == WrkStsType.OUTBOUND_RUN.sts) {
|
updateWrkSts = WrkStsType.OUTBOUND_RUN_COMPLETE.sts;
|
|
// 生成仿真站点数据
|
List<StationObjModel> outStationList = basCrnp.getOutStationList$();
|
if (outStationList.isEmpty()) {
|
News.info("堆垛机:{} 出库站点未设置", basCrnp.getCrnNo());
|
continue;
|
}
|
|
for (StationObjModel stationObjModel : outStationList) {
|
if (!stationObjModel.getStationId().equals(wrkMast.getSourceStaNo())) {
|
continue;
|
}
|
|
StationThread stationThread = (StationThread) SlaveConnection.get(SlaveType.Devp,
|
stationObjModel.getDeviceNo());
|
if (stationThread == null) {
|
continue;
|
}
|
// 生成仿真站点数据
|
StationCommand command = stationThread.getCommand(StationCommandType.WRITE_INFO, 9998,
|
wrkMast.getSourceStaNo(), 0, 0);
|
stationCommandDispatcher.dispatch(stationObjModel.getDeviceNo(), command, "fake-process", "crn-out-complete-write-info");
|
redisUtil.set(RedisKeyType.CRN_OUT_TASK_COMPLETE_STATION_INFO.key + wrkMast.getWrkNo(), JSON.toJSONString(stationObjModel, SerializerFeature.DisableCircularReferenceDetect), 60 * 60 * 24);
|
}
|
} else if (wrkMast.getWrkSts() == WrkStsType.LOC_MOVE_RUN.sts) {
|
updateWrkSts = WrkStsType.COMPLETE_LOC_MOVE.sts;
|
} else if (wrkMast.getWrkSts() == WrkStsType.CRN_MOVE_RUN.sts) {
|
updateWrkSts = WrkStsType.COMPLETE_CRN_MOVE.sts;
|
} else {
|
News.error("堆垛机处于等待确认且任务完成状态，但工作状态异常。堆垛机号={}，工作号={}", basCrnp.getCrnNo(), crnProtocol.getTaskNo());
|
continue;
|
}
|
|
Date now = new Date();
|
wrkMast.setWrkSts(updateWrkSts);
|
wrkMast.setSystemMsg("");
|
wrkMast.setIoTime(now);
|
wrkMast.setModiTime(now);
|
if (wrkMastService.updateById(wrkMast)) {
|
wrkAnalysisService.markCraneComplete(wrkMast, now, updateWrkSts);
|
CrnCommand resetCommand = crnThread.getResetCommand(crnProtocol.getTaskNo(), crnProtocol.getCrnNo());
|
MessageQueue.offer(SlaveType.Crn, crnProtocol.getCrnNo(), new Task(2, resetCommand));
|
News.info("堆垛机任务状态更新成功，堆垛机号={}，工作号={}", basCrnp.getCrnNo(), crnProtocol.getTaskNo());
|
}
|
|
redisUtil.set(RedisKeyType.CRN_IO_EXECUTE_FINISH_LIMIT.key + basCrnp.getCrnNo(), "lock", 10);
|
}
|
}
|
}
|
|
}
|
