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.mapper.EntityWrapper;
|
import com.core.common.Cools;
|
import com.core.exception.CoolException;
|
import com.zy.asrs.domain.enums.NotifyMsgType;
|
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 {
|
|
@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;
|
|
//执行输送站点入库任务
|
public synchronized void stationInExecute() {
|
try {
|
List<BasDevp> basDevps = basDevpService.selectList(new EntityWrapper<>());
|
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.selectOne(new EntityWrapper<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;
|
}
|
|
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);
|
}
|
}
|
}
|
}
|
} catch (Exception e) {
|
e.printStackTrace();
|
}
|
}
|
|
//执行堆垛机输送站点出库任务
|
public synchronized void crnStationOutExecute() {
|
try {
|
List<WrkMast> wrkMasts = wrkMastService.selectList(new EntityWrapper<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
|
) {
|
Integer moveStaNo = wrkMast.getStaNo();
|
|
if (!outOrderList.isEmpty()) {
|
List<NavigateNode> nodes = navigateUtils.calcByStationId(stationProtocol.getStationId(), wrkMast.getStaNo());
|
for (int i = nodes.size() - 1; i >= 0; i--) {
|
NavigateNode node = nodes.get(i);
|
JSONObject v = JSONObject.parseObject(node.getNodeValue());
|
if (v != null) {
|
Integer stationId = v.getInteger("stationId");
|
if (outOrderList.contains(stationId)) {
|
moveStaNo = stationId;
|
break;
|
}
|
}
|
}
|
}
|
|
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());
|
}
|
}
|
}
|
} catch (Exception e) {
|
e.printStackTrace();
|
}
|
}
|
|
//执行双工位堆垛机输送站点出库任务
|
public synchronized void dualCrnStationOutExecute() {
|
try {
|
List<WrkMast> wrkMasts = wrkMastService.selectList(new EntityWrapper<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.selectList(new EntityWrapper<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.selectOne(new EntityWrapper<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);
|
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.selectList(new EntityWrapper<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.selectOne(new EntityWrapper<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.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重新分配库位接口失败，接口未响应！！！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 {
|
//运行堵塞，重新计算路线
|
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>());
|
for (BasDevp basDevp : basDevps) {
|
StationThread stationThread = (StationThread) SlaveConnection.get(SlaveType.Devp, basDevp.getId());
|
if (stationThread == null) {
|
continue;
|
}
|
|
for (StationProtocol stationProtocol : stationThread.getStatus()) {
|
if (stationProtocol.getTaskNo() > 0) {
|
currentStationTaskCount++;
|
}
|
}
|
}
|
|
return currentStationTaskCount;
|
}
|
|
// 检测出库排序
|
public synchronized void checkStationOutOrder() {
|
List<BasDevp> basDevps = basDevpService.selectList(new EntityWrapper<BasDevp>());
|
for (BasDevp basDevp : basDevps) {
|
StationThread stationThread = (StationThread) SlaveConnection.get(SlaveType.Devp, basDevp.getId());
|
if (stationThread == null) {
|
continue;
|
}
|
Map<Integer, StationProtocol> statusMap = stationThread.getStatusMap();
|
List<StationObjModel> orderList = basDevp.getOutOrderList$();
|
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 (Cools.isEmpty(wrkMast.getBatch())) {
|
continue;
|
}
|
|
if (Cools.isEmpty(wrkMast.getBatchSeq())) {
|
continue;
|
}
|
|
List<WrkMast> batchWrkList = wrkMastService.selectList(new EntityWrapper<WrkMast>()
|
.notIn("wrk_sts", WrkStsType.STATION_RUN_COMPLETE.sts, WrkStsType.COMPLETE_OUTBOUND.sts)
|
.eq("batch", wrkMast.getBatch())
|
.orderBy("batch")
|
);
|
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;
|
}
|
MessageQueue.offer(SlaveType.Devp, stationObjModel.getDeviceNo(), new Task(2, command));
|
News.info("{}任务直接去目标点", wrkMast.getWrkNo());
|
} else if (commandType.equals("toCircle")) {
|
Integer circleTarget = null;
|
for (NavigateNode node : initPath) {
|
JSONObject v = JSONObject.parseObject(node.getNodeValue());
|
if (v != null) {
|
Integer stationId = v.getInteger("stationId");
|
try {
|
List<NavigateNode> enableMovePath = navigateUtils.calcByStationId(stationProtocol.getStationId(), stationId);
|
if (enableMovePath.isEmpty()) {
|
continue;
|
}
|
} catch (Exception e) {
|
continue;
|
}
|
|
circleTarget = stationId;
|
break;
|
}
|
}
|
|
if (circleTarget == null) {
|
continue;
|
}
|
|
StationCommand command = stationThread.getCommand(StationCommandType.MOVE, wrkMast.getWrkNo(), stationProtocol.getStationId(), circleTarget, 0);
|
if (command == null) {
|
News.taskInfo(wrkMast.getWrkNo(), "获取输送线命令失败");
|
continue;
|
}
|
MessageQueue.offer(SlaveType.Devp, stationObjModel.getDeviceNo(), new Task(2, command));
|
redisUtil.set(RedisKeyType.WATCH_CIRCLE_STATION_.key + wrkMast.getWrkNo(), JSON.toJSONString(command, SerializerFeature.DisableCircularReferenceDetect), 60 * 60 * 24);
|
News.info("{}任务进行绕圈", wrkMast.getWrkNo());
|
}
|
}
|
}
|
}
|
|
// 监控绕圈站点
|
public synchronized void watchCircleStation() {
|
List<BasDevp> basDevps = basDevpService.selectList(new EntityWrapper<BasDevp>());
|
for (BasDevp basDevp : basDevps) {
|
StationThread stationThread = (StationThread) SlaveConnection.get(SlaveType.Devp, basDevp.getId());
|
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;
|
}
|
|
Object circleObj = redisUtil.get(RedisKeyType.WATCH_CIRCLE_STATION_.key + stationProtocol.getTaskNo());
|
if (circleObj == null) {
|
continue;
|
}
|
|
StationCommand circleCommand = JSON.parseObject(circleObj.toString(), StationCommand.class);
|
if (!stationProtocol.getStationId().equals(circleCommand.getTargetStaNo())) {
|
continue;
|
}
|
|
WrkMast wrkMast = wrkMastService.selectByWorkNo(stationProtocol.getTaskNo());
|
if (wrkMast == null) {
|
continue;
|
}
|
|
Integer moveStaNo = wrkMast.getStaNo();
|
|
if (!outOrderList.isEmpty()) {
|
List<NavigateNode> nodes = navigateUtils.calcByStationId(stationProtocol.getStationId(), wrkMast.getStaNo());
|
for (int i = nodes.size() - 1; i >= 0; i--) {
|
NavigateNode node = nodes.get(i);
|
JSONObject v = JSONObject.parseObject(node.getNodeValue());
|
if (v != null) {
|
Integer stationId = v.getInteger("stationId");
|
if (outOrderList.contains(stationId)) {
|
moveStaNo = stationId;
|
break;
|
}
|
}
|
}
|
}
|
|
StationCommand command = stationThread.getCommand(StationCommandType.MOVE, wrkMast.getWrkNo(), stationProtocol.getStationId(), moveStaNo, 0);
|
if (command == null) {
|
News.taskInfo(wrkMast.getWrkNo(), "获取输送线命令失败");
|
continue;
|
}
|
MessageQueue.offer(SlaveType.Devp, basDevp.getDevpNo(), new Task(2, command));
|
}
|
}
|
}
|
|
public List<Integer> getAllOutOrderList() {
|
List<Integer> list = new ArrayList<>();
|
List<BasDevp> basDevps = basDevpService.selectList(new EntityWrapper<BasDevp>());
|
for (BasDevp basDevp : basDevps) {
|
List<Integer> orderList = basDevp.getOutOrderIntList();
|
list.addAll(orderList);
|
}
|
return list;
|
}
|
|
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.selectOne(new EntityWrapper<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;
|
}
|
|
}
|
