package com.mes.job;
|
|
import cn.hutool.core.collection.CollectionUtil;
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
|
import com.kangaroohy.milo.model.ReadWriteEntity;
|
import com.kangaroohy.milo.service.MiloService;
|
import com.mes.common.config.Const;
|
import com.mes.engineering.entity.Engineering;
|
import com.mes.engineering.mapper.EngineeringMapper;
|
import com.mes.opctask.entity.LoadGlassDeviceTask;
|
import com.mes.opctask.service.LoadGlassDeviceTaskService;
|
import com.mes.rawglassdetails.entity.RawGlassStorageDetails;
|
import com.mes.rawglassdetails.service.RawGlassStorageDetailsService;
|
import com.mes.rawglassstation.entity.RawGlassStorageStation;
|
import com.mes.rawglassstation.service.RawGlassStorageStationService;
|
import com.mes.rawglasstask.entity.RawGlassStorageTask;
|
import com.mes.rawglasstask.service.RawGlassStorageTaskService;
|
import com.mes.uppattenusage.entity.UpPattenUsage;
|
import com.mes.uppattenusage.entity.vo.UpPattenUsageVO;
|
import com.mes.uppattenusage.mapper.UpPattenUsageMapper;
|
import lombok.extern.slf4j.Slf4j;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.scheduling.annotation.Scheduled;
|
import org.springframework.stereotype.Component;
|
import org.springframework.util.CollectionUtils;
|
|
import javax.annotation.Resource;
|
import java.util.*;
|
import java.util.stream.Collectors;
|
|
/**
|
* @Author : zhoush
|
* @Date: 2024/10/11 16:13
|
* @Description:
|
*/
|
@Slf4j
|
@Component
|
public class RawGlassTask {
|
|
@Autowired
|
private RawGlassStorageDetailsService rawGlassStorageDetailsService;
|
|
@Autowired
|
private RawGlassStorageTaskService rawGlassStorageTaskService;
|
@Autowired
|
private RawGlassStorageStationService rawGlassStorageStationService;
|
|
@Resource
|
private EngineeringMapper engineeringMapper;
|
@Resource
|
private UpPattenUsageMapper upPattenUsageMapper;
|
|
@Resource
|
private LoadGlassDeviceTaskService loadGlassDeviceTaskService;
|
|
@Autowired(required = false)
|
private MiloService miloService;
|
|
|
private static final String LOAD_GLASS_DEVICE_ONE_TASK = "load_glass_device_one_task";
|
|
private static final String LOAD_GLASS_DEVICE_TWO_TASK = "load_glass_device_two_task";
|
|
private static final List<Integer> LOAD_STATION_01 = Arrays.asList(101, 102);
|
private static final List<Integer> LOAD_STATION_02 = Arrays.asList(103, 104);
|
private static final Integer LEFTING_01 = 98;
|
private static final Integer LEFTING_02 = 99;
|
private static final Integer LOAD_GLASS_ONE_DEVICE = 5;
|
private static final Integer LOAD_GLASS_TWO_DEVICE = 6;
|
|
@Scheduled(fixedDelay = 1000)
|
public void rawStorageTask() throws Exception {
|
ReadWriteEntity requestWord = miloService.readFromOpcUa("CC.CC.request");
|
ReadWriteEntity confireWord = miloService.readFromOpcUa("CC.CC.confirmation");
|
ReadWriteEntity reportWord = miloService.readFromOpcUa("CC.CC.reportWord");
|
ReadWriteEntity taskWord = miloService.readFromOpcUa("CC.CC.taskWord");
|
String requestValue = requestWord.getValue() + "";
|
if ("0".equals(requestValue)) {
|
if ("1".equals(confireWord.getValue() + "") && "0".equals(reportWord.getValue() + "")) {
|
List<ReadWriteEntity> list = new ArrayList<>();
|
list.add(generateReadWriteEntity("CC.CC.confirmation", 0));
|
miloService.writeToOpcWord(list);
|
}
|
if ("1".equals(taskWord.getValue() + "")) {
|
List<ReadWriteEntity> list = new ArrayList<>();
|
list.add(generateReadWriteEntity("CC.CC.taskWord", 0));
|
list.add(generateReadWriteEntity("CC.CC.startSlot", 0));
|
list.add(generateReadWriteEntity("CC.CC.endSlot", 0));
|
miloService.writeToOpcWord(list);
|
}
|
return;
|
}
|
if (!"1".equals(requestValue)) {
|
log.info("无请求");
|
return;
|
}
|
//是否有正在执行的任务
|
boolean flag = isHasRunningTask();
|
if (flag) {
|
log.info("有未完成的任务，结束");
|
return;
|
}
|
//todo:优先进上片机位
|
flag = rawGlassDispatchTask();
|
if (flag) {
|
log.info("执行调度任务，结束");
|
return;
|
}
|
flag = outboundTask();
|
if (flag) {
|
log.info("执行出库任务，结束");
|
return;
|
}
|
flag = warehouseTask();
|
if (flag) {
|
log.info("执行入库任务");
|
return;
|
}
|
log.info("无任务执行，结束");
|
}
|
|
@Scheduled(fixedDelay = 1000)
|
public void rawStorageInCar() throws Exception {
|
ReadWriteEntity entity = miloService.readFromOpcUa("CC.CC.inCar");
|
String value = entity.getValue() + "";
|
if (!"1".equals(value)) {
|
log.info("大车上没有架子");
|
return;
|
}
|
//查询任务
|
RawGlassStorageDetails one = rawGlassStorageDetailsService.getOne(new LambdaQueryWrapper<RawGlassStorageDetails>()
|
.eq(RawGlassStorageDetails::getState, Const.RAW_GLASS_STATE_RUNNING));
|
if (one == null) {
|
log.info("没有正在执行的任务");
|
return;
|
}
|
rawGlassStorageDetailsService.update(new LambdaUpdateWrapper<RawGlassStorageDetails>().eq(RawGlassStorageDetails::getId, one.getId())
|
.set(RawGlassStorageDetails::getState, Const.RAW_GLASS_STATE_CAR));
|
|
}
|
|
@Scheduled(fixedDelay = 1000)
|
public void rawStorageFinish() throws Exception {
|
ReadWriteEntity entity = miloService.readFromOpcUa("CC.CC.reportWord");
|
String value = entity.getValue() + "";
|
if ("0".equals(value)) {
|
log.info("当前任务未汇报，结束本次任务");
|
return;
|
}
|
RawGlassStorageDetails details = rawGlassStorageDetailsService.getOne(new LambdaUpdateWrapper<RawGlassStorageDetails>()
|
.eq(RawGlassStorageDetails::getState, Const.RAW_GLASS_STATE_CAR));
|
if (null == details) {
|
log.info("无执行中的任务");
|
return;
|
}
|
RawGlassStorageTask task = rawGlassStorageTaskService.getOne(new LambdaQueryWrapper<RawGlassStorageTask>()
|
.in(RawGlassStorageTask::getTaskState, Const.RAW_GLASS_TASK_NEW));
|
RawGlassStorageDetails targetDetails = generateDetails(details, task.getEndSlot());
|
int deviceId = details.getDeviceId();
|
Integer taskType = task.getTaskType();
|
if ("1".equals(value)) {
|
log.info("将详情表的状态改为已出库");
|
rawGlassStorageDetailsService.update(new LambdaUpdateWrapper<RawGlassStorageDetails>()
|
.set(RawGlassStorageDetails::getState, Const.RAW_GLASS_STATE_OUT)
|
.eq(RawGlassStorageDetails::getSlot, task.getStartSlot()).eq(RawGlassStorageDetails::getState, Const.RAW_GLASS_STATE_CAR));
|
log.info("任务状态已更改为：已完成");
|
rawGlassStorageTaskService.update(new LambdaUpdateWrapper<RawGlassStorageTask>()
|
.eq(RawGlassStorageTask::getTaskState, Const.RAW_GLASS_TASK_NEW)
|
.set(RawGlassStorageTask::getTaskState, Const.RAW_GLASS_TASK_SUCCESS));
|
switch (taskType) {
|
case 1:
|
case 3:
|
log.info("1、入库，3、调度任务。{}", taskType);
|
if (targetDetails.getRemainQuantity() > 0) {
|
rawGlassStorageDetailsService.save(targetDetails);
|
}
|
break;
|
case 2:
|
case 4:
|
log.info("2、出片,4、入库请求。{}", taskType);
|
targetDetails = new RawGlassStorageDetails();
|
targetDetails.setSlot(task.getEndSlot());
|
targetDetails.setDeviceId(deviceId);
|
targetDetails.setShelf(task.getStartSlot());
|
targetDetails.setState(Const.RAW_GLASS_STATE_IN);
|
rawGlassStorageDetailsService.save(targetDetails);
|
break;
|
default:
|
break;
|
}
|
} else {
|
if (taskType.equals(Const.RAW_GLASS_TASK_TYPE_IN_REQUEST)) {
|
rawGlassStorageDetailsService.update(new LambdaUpdateWrapper<RawGlassStorageDetails>()
|
.set(RawGlassStorageDetails::getState, Const.RAW_GLASS_STATE_OUT)
|
.eq(RawGlassStorageDetails::getSlot, task.getStartSlot())
|
.in(RawGlassStorageDetails::getState, Const.RAW_GLASS_STATE_RUNNING, Const.RAW_GLASS_STATE_CAR));
|
} else {
|
rawGlassStorageDetailsService.update(new LambdaUpdateWrapper<RawGlassStorageDetails>()
|
.set(RawGlassStorageDetails::getState, Const.RAW_GLASS_STATE_IN)
|
.eq(RawGlassStorageDetails::getSlot, task.getStartSlot())
|
.in(RawGlassStorageDetails::getState, Const.RAW_GLASS_STATE_RUNNING, Const.RAW_GLASS_STATE_CAR));
|
}
|
rawGlassStorageTaskService.update(new LambdaUpdateWrapper<RawGlassStorageTask>()
|
.eq(RawGlassStorageTask::getTaskState, Const.RAW_GLASS_TASK_NEW)
|
.set(RawGlassStorageTask::getTaskState, Const.RAW_GLASS_TASK_FAILURE));
|
|
}
|
List<ReadWriteEntity> list = new ArrayList<>();
|
list.add(generateReadWriteEntity("CC.CC.confirmation", 1));
|
miloService.writeToOpcWord(list);
|
}
|
|
private boolean isHasRunningTask() {
|
RawGlassStorageTask task = rawGlassStorageTaskService.getOne(new LambdaQueryWrapper<RawGlassStorageTask>()
|
.in(RawGlassStorageTask::getTaskState, Const.RAW_GLASS_TASK_NEW));
|
return task == null ? Boolean.FALSE : Boolean.TRUE;
|
}
|
|
/**
|
* 原片调度：1、查询工程原片表，按照顺序将原片放入上片1号位，后续原片放上片2号位，出现尺寸替换，判断原上片位是否有玻璃，有 先出后进，无 直接进片
|
*/
|
public boolean rawGlassDispatchTask() throws Exception {
|
//查询当前系统正在执行的订单
|
List<Engineering> engineeringList = engineeringMapper.selectList(new LambdaQueryWrapper<Engineering>()
|
.eq(Engineering::getState, Const.ENGINEERING_RUNNING).last("order by id"));
|
if (CollectionUtils.isEmpty(engineeringList)) {
|
log.info("没有正在执行的工程");
|
return false;
|
}
|
for (Engineering engineering : engineeringList) {
|
boolean flag = rawGlassDispatchByEngineering(engineering.getStationCell(), engineering.getEngineerId());
|
if (flag) {
|
return flag;
|
}
|
}
|
return Boolean.FALSE;
|
|
|
}
|
|
/**
|
* 出库任务：1、点出库，立马生成出片任务 2、点出库修改工位详情内的状态为待出库，定时任务扫描生成出库任务
|
*/
|
public boolean outboundTask() throws Exception {
|
List<RawGlassStorageDetails> rawGlassList = rawGlassStorageDetailsService.list(new LambdaQueryWrapper<RawGlassStorageDetails>()
|
.eq(RawGlassStorageDetails::getState, Const.RAW_GLASS_STATE_WAIT_OUT)
|
.inSql(RawGlassStorageDetails::getSlot, "select slot from raw_glass_storage_station where enable_state = 1"));
|
if (CollectionUtil.isEmpty(rawGlassList)) {
|
log.info("系统没有需要出库的原片信息");
|
return Boolean.FALSE;
|
}
|
//获取工位上是否有架子，
|
List<RawGlassStorageDetails> emptyLeftingList = rawGlassStorageDetailsService.list(new LambdaQueryWrapper<RawGlassStorageDetails>()
|
.in(RawGlassStorageDetails::getState, Const.RAW_GLASS_STATE_IN_ALL)
|
.in(RawGlassStorageDetails::getSlot, "select slot from raw_glass_storage_station where enable_state = 1 and device_id = 4"));
|
if (CollectionUtil.isNotEmpty(emptyLeftingList) && emptyLeftingList.size() > 1) {
|
log.info("吊装位当前都有架子，结束出片任务");
|
return Boolean.FALSE;
|
}
|
//获取需要落架的
|
List<Integer> leftingList = emptyLeftingList.stream().map(RawGlassStorageDetails::getSlot).collect(Collectors.toList());
|
int lefting = CollectionUtil.isEmpty(leftingList) ? LEFTING_01 : leftingList.get(0).equals(LEFTING_01) ? LEFTING_02 : LEFTING_01;
|
Integer startSlot = rawGlassList.get(0).getSlot();
|
//生成出库任务
|
rawGlassStorageDetailsService.generateTask(startSlot, lefting, startSlot, rawGlassList.get(0).getRemainQuantity(), Const.RAW_GLASS_TASK_TYPE_OUT);
|
|
// List<ReadWriteEntity> list = new ArrayList<>();
|
// list.add(generateReadWriteEntity("CC.CC.taskWord", 1));
|
// list.add(generateReadWriteEntity("CC.CC.taskSending", 1));
|
// list.add(generateReadWriteEntity("CC.CC.startSlot", startSlot));
|
// list.add(generateReadWriteEntity("CC.CC.endSlot", lefting));
|
// miloService.writeToOpcWord(list);
|
|
//修改出片任务状态
|
rawGlassStorageDetailsService.update(new LambdaUpdateWrapper<RawGlassStorageDetails>()
|
.eq(RawGlassStorageDetails::getSlot, rawGlassList.get(0).getSlot())
|
.eq(RawGlassStorageDetails::getState, Const.RAW_GLASS_STATE_WAIT_OUT)
|
.set(RawGlassStorageDetails::getState, Const.RAW_GLASS_STATE_RUNNING));
|
return Boolean.TRUE;
|
}
|
|
/**
|
* 入库任务：吊装位有玻璃，先去工位表查询空格子，生成入库任务从吊装位到目标格子
|
*
|
* @throws Exception
|
*/
|
public boolean warehouseTask() throws Exception {
|
List<RawGlassStorageDetails> rawGlassList = rawGlassStorageDetailsService.list(new LambdaQueryWrapper<RawGlassStorageDetails>()
|
.eq(RawGlassStorageDetails::getState, Const.GLASS_STATE_IN)
|
.gt(RawGlassStorageDetails::getRemainQuantity, 0)
|
.inSql(RawGlassStorageDetails::getSlot, "select slot from raw_glass_storage_station where enable_state = 1 and device_id = 4")
|
.inSql(RawGlassStorageDetails::getShelf, "select slot from raw_glass_storage_station where enable_state = 1 "));
|
if (CollectionUtil.isEmpty(rawGlassList)) {
|
log.info("吊装位被禁用/架子所在工位被禁用/无原片信息");
|
return Boolean.FALSE;
|
}
|
//生成进笼任务
|
RawGlassStorageDetails details = rawGlassList.get(0);
|
rawGlassStorageDetailsService.generateTask(details.getSlot(), details.getShelf(), details.getShelf(),
|
details.getRemainQuantity(), Const.RAW_GLASS_TASK_TYPE_IN);
|
// List<ReadWriteEntity> list = new ArrayList<>();
|
// list.add(generateReadWriteEntity("CC.CC.taskWord", 1));
|
// list.add(generateReadWriteEntity("CC.CC.taskSending", 1));
|
// list.add(generateReadWriteEntity("CC.CC.startSlot", details.getSlot()));
|
// list.add(generateReadWriteEntity("CC.CC.endSlot", details.getShelf()));
|
// miloService.writeToOpcWord(list);
|
//生成工位任务，将吊装位的玻璃状态改位进笼中
|
//修改吊装位的原片状态为103 出片中
|
//修改出片任务状态
|
rawGlassStorageDetailsService.update(new LambdaUpdateWrapper<RawGlassStorageDetails>()
|
.eq(RawGlassStorageDetails::getSlot, rawGlassList.get(0).getSlot())
|
.eq(RawGlassStorageDetails::getState, Const.GLASS_STATE_IN)
|
.set(RawGlassStorageDetails::getState, Const.RAW_GLASS_STATE_RUNNING));
|
return Boolean.TRUE;
|
}
|
|
/**
|
* @param stationCell 设备信息 5 、 6
|
* @param enginneerId 共亨号
|
* @return
|
* @throws Exception
|
*/
|
private boolean rawGlassDispatchByEngineering(int stationCell, String enginneerId) throws Exception {
|
//当前尺寸需要上片的数量
|
List<UpPattenUsageVO> pattenUsageList = upPattenUsageMapper.queryRawGlassByEngineeringId(enginneerId);
|
if (CollectionUtils.isEmpty(pattenUsageList)) {
|
log.info("正在执行的工程原片无可上片的原片信息");
|
return Boolean.FALSE;
|
}
|
//获取当前需要上片的原片数据
|
Map<String, List<UpPattenUsageVO>> upListMap = pattenUsageList.stream()
|
.collect(Collectors.groupingBy(UpPattenUsageVO::getGroupNumber));
|
List<UpPattenUsageVO> usageVOS = upListMap.get("1");
|
//获取当前上片位1号架子信息
|
List<Integer> loadStation = LOAD_GLASS_ONE_DEVICE.equals(stationCell) ? LOAD_STATION_01 : LOAD_STATION_02;
|
List<RawGlassStorageStation> stations = rawGlassStorageStationService.list(new LambdaQueryWrapper<RawGlassStorageStation>()
|
.in(RawGlassStorageStation::getSlot, loadStation)
|
.eq(RawGlassStorageStation::getEnableState, Const.SLOT_ON).orderByAsc(RawGlassStorageStation::getSlot));
|
if (CollectionUtils.isEmpty(stations)) {
|
log.info("没有可用的上片位");
|
return Boolean.FALSE;
|
}
|
|
|
List<RawGlassStorageDetails> loadStationList = rawGlassStorageDetailsService.list(new LambdaQueryWrapper<RawGlassStorageDetails>()
|
.inSql(RawGlassStorageDetails::getSlot, "select slot from raw_glass_storage_station where enable_state = 1")
|
.eq(RawGlassStorageDetails::getState, Const.RAW_GLASS_STATE_IN)
|
.eq(RawGlassStorageDetails::getDeviceId, stationCell));
|
if (stations.size() == 1) {
|
if (CollectionUtils.isEmpty(loadStationList)) {
|
RawGlassStorageDetails rawDetails = getRawGlassStorageDetailsBySize(usageVOS.get(0), usageVOS.size());
|
rawGlassStorageDetailsService.generateTask(rawDetails.getSlot(), stations.get(0).getSlot(), rawDetails.getShelf(), rawDetails.getRemainQuantity(), Const.RAW_GLASS_TASK_TYPE_DISPATCH);
|
//结束调度任务 修改工位状态(起始位）状态为103 RAW_GLASS_STATE_RUNNING 任务完成后将状态改为101 目标位新增一条数据，架子号为（起始位）
|
rawGlassStorageDetailsService.update(new LambdaUpdateWrapper<RawGlassStorageDetails>()
|
.eq(RawGlassStorageDetails::getSlot, rawDetails.getSlot()).eq(RawGlassStorageDetails::getState, Const.RAW_GLASS_STATE_IN)
|
.set(RawGlassStorageDetails::getState, Const.RAW_GLASS_STATE_RUNNING));
|
return Boolean.TRUE;
|
}
|
RawGlassStorageDetails oneLoadStation = loadStationList.get(0);
|
if (oneLoadStation.getRemainQuantity() <= 0 || !compareRawSize(usageVOS.get(0), oneLoadStation)) {
|
rawGlassStorageDetailsService.generateTask(stations.get(0).getSlot(), oneLoadStation.getShelf(), oneLoadStation.getShelf(), oneLoadStation.getRemainQuantity(), Const.RAW_GLASS_TASK_TYPE_DISPATCH);
|
rawGlassStorageDetailsService.update(new LambdaUpdateWrapper<RawGlassStorageDetails>()
|
.eq(RawGlassStorageDetails::getSlot, oneLoadStation.getSlot()).eq(RawGlassStorageDetails::getState, Const.RAW_GLASS_STATE_IN)
|
.set(RawGlassStorageDetails::getDeviceId, Const.RAW_GLASS_STATE_RUNNING));
|
return Boolean.FALSE;
|
}
|
}
|
|
log.info("获取{}上片线的工位信息{}", stationCell, loadStationList);
|
if (CollectionUtils.isEmpty(loadStationList)) {
|
log.info("1号上片位生成调度任务");
|
RawGlassStorageDetails rawDetails = getRawGlassStorageDetailsBySize(usageVOS.get(0), usageVOS.size());
|
rawGlassStorageDetailsService.generateTask(rawDetails.getSlot(), loadStation.get(0), rawDetails.getShelf(), rawDetails.getRemainQuantity(), Const.RAW_GLASS_TASK_TYPE_DISPATCH);
|
//结束调度任务 修改工位状态(起始位）状态为103 RAW_GLASS_STATE_RUNNING 任务完成后将状态改为101 目标位新增一条数据，架子号为（起始位）
|
rawGlassStorageDetailsService.update(new LambdaUpdateWrapper<RawGlassStorageDetails>()
|
.eq(RawGlassStorageDetails::getSlot, rawDetails.getSlot()).eq(RawGlassStorageDetails::getState, Const.RAW_GLASS_STATE_IN)
|
.set(RawGlassStorageDetails::getState, Const.RAW_GLASS_STATE_RUNNING));
|
return Boolean.TRUE;
|
}
|
RawGlassStorageDetails oneLoadStation = loadStationList.stream().filter(e -> e.getSlot().equals(loadStation.get(0))).findFirst().orElse(null);
|
if (null == oneLoadStation) {
|
RawGlassStorageDetails twoLoadStation = loadStationList.stream().filter(e -> e.getSlot().equals(loadStation.get(1))).findFirst().orElse(null);
|
if (twoLoadStation.getRemainQuantity() > 0) {
|
if (compareRawSize(usageVOS.get(0), twoLoadStation)) {
|
// 2号上片位的原片信息源工程信息一致，可上片操作，结束本次任务
|
return Boolean.FALSE;
|
} else {
|
// 生成1号位入库任务
|
log.info("2号上片位玻璃尺寸不一致，1号上片位生成调度任务");
|
//按照尺寸及数量获取数量最接近的格子信息
|
RawGlassStorageDetails rawDetails = getRawGlassStorageDetailsBySize(usageVOS.get(0), usageVOS.size());
|
if(null == rawDetails){
|
log.info("仓库内无需要上架的玻璃");
|
return Boolean.FALSE;
|
}
|
rawGlassStorageDetailsService.generateTask(rawDetails.getSlot(), loadStation.get(0), rawDetails.getShelf(), rawDetails.getRemainQuantity(), Const.RAW_GLASS_TASK_TYPE_DISPATCH);
|
//结束调度任务 修改工位状态(起始位）状态为103 RAW_GLASS_STATE_RUNNING 任务完成后将状态改为101 目标位新增一条数据，架子号为（起始位）
|
rawGlassStorageDetailsService.update(new LambdaUpdateWrapper<RawGlassStorageDetails>()
|
.eq(RawGlassStorageDetails::getSlot, rawDetails.getSlot()).eq(RawGlassStorageDetails::getState, Const.RAW_GLASS_STATE_IN)
|
.set(RawGlassStorageDetails::getState, Const.RAW_GLASS_STATE_RUNNING));
|
return Boolean.TRUE;
|
}
|
} else {
|
// 生成1号位入库任务
|
log.info("2号上片位仅剩空架子，1号上片位生成调度任务");
|
RawGlassStorageDetails rawDetails = getRawGlassStorageDetailsBySize(usageVOS.get(0), usageVOS.size());
|
rawGlassStorageDetailsService.generateTask(rawDetails.getSlot(), loadStation.get(0), rawDetails.getShelf(), rawDetails.getRemainQuantity(), Const.RAW_GLASS_TASK_TYPE_DISPATCH);
|
rawGlassStorageDetailsService.update(new LambdaUpdateWrapper<RawGlassStorageDetails>()
|
.eq(RawGlassStorageDetails::getSlot, rawDetails.getSlot()).eq(RawGlassStorageDetails::getState, Const.RAW_GLASS_STATE_IN)
|
.set(RawGlassStorageDetails::getState, Const.RAW_GLASS_STATE_RUNNING));
|
return Boolean.TRUE;
|
}
|
} else {
|
String tableName = stationCell == 5 ? LOAD_GLASS_DEVICE_ONE_TASK : LOAD_GLASS_DEVICE_TWO_TASK;
|
if (oneLoadStation.getRemainQuantity() > 0) {
|
if (compareRawSize(usageVOS.get(0), oneLoadStation)) {
|
//结束仓储调度，等待上片任务
|
//在上片任务执行空闲过程中,可执行二号位出入库任务 二号架子的信息是否需要调度,不需要调度直接放回false
|
log.info("获取二号位原片信息");
|
RawGlassStorageDetails twoLoadStation = loadStationList.stream().filter(e -> e.getSlot().equals(loadStation.get(1))).findFirst().orElse(null);
|
if (null == twoLoadStation) {
|
//按照尺寸生成二号位上片任务信息
|
LoadGlassDeviceTask loadTask = loadGlassDeviceTaskService.queryTaskMessage(tableName);
|
RawGlassStorageDetails rawDetails = null;
|
if (oneLoadStation.getRemainQuantity() > (loadTask.getTotalCount() + loadTask.getDamageCount())) {
|
usageVOS = upListMap.get("2");
|
if (CollectionUtils.isEmpty(usageVOS)) {
|
log.info("当前工程的原片即将用完，结束本次调度");
|
return Boolean.FALSE;
|
}
|
rawDetails = getRawGlassStorageDetailsBySize(usageVOS.get(0), usageVOS.size());
|
} else {
|
rawDetails = getRawGlassStorageDetailsBySize(usageVOS.get(0), usageVOS.size());
|
|
}
|
if (null == rawDetails) {
|
log.info("原片仓储没有相同尺寸的玻璃");
|
return Boolean.FALSE;
|
}
|
rawGlassStorageDetailsService.generateTask(rawDetails.getSlot(), loadStation.get(1), rawDetails.getShelf(), rawDetails.getRemainQuantity(), Const.RAW_GLASS_TASK_TYPE_DISPATCH);
|
//结束调度任务 修改工位状态(起始位）状态为103 RAW_GLASS_STATE_RUNNING 任务完成后将状态改为101 目标位新增一条数据，架子号为（起始位）
|
rawGlassStorageDetailsService.update(new LambdaUpdateWrapper<RawGlassStorageDetails>()
|
.eq(RawGlassStorageDetails::getSlot, rawDetails.getSlot()).eq(RawGlassStorageDetails::getState, Const.RAW_GLASS_STATE_IN)
|
.set(RawGlassStorageDetails::getState, Const.RAW_GLASS_STATE_RUNNING));
|
return Boolean.TRUE;
|
} else {
|
//todo:当二号为的尺寸大于0时，是否执行调度任务，更换当前原片的尺寸，等待下一次任务的直接执行；还是继续等待，当尺寸不一样，等待一号工位的进出库调度任务。
|
if (twoLoadStation.getRemainQuantity() > 0) {
|
LoadGlassDeviceTask loadTask = loadGlassDeviceTaskService.queryTaskMessage(tableName);
|
if (oneLoadStation.getRemainQuantity() > (loadTask.getTotalCount() + loadTask.getDamageCount())) {
|
usageVOS = upListMap.get("2");
|
if (CollectionUtils.isEmpty(usageVOS)) {
|
log.info("当前工程的原片即将用完，结束本次调度");
|
return Boolean.FALSE;
|
}
|
}
|
if (compareRawSize(usageVOS.get(0), twoLoadStation)) {
|
// //2号上片位的原片信息源工程信息一致，可上片操作，结束本次任务
|
return Boolean.FALSE;
|
} else {
|
// 生成1号位入库任务
|
log.info("2号上片位玻璃尺寸不一致，2号上片位生成出片调度任务");
|
//按照尺寸及数量获取数量最接近的格子信息
|
rawGlassStorageDetailsService.generateTask(loadStation.get(1), twoLoadStation.getShelf(), twoLoadStation.getShelf(), twoLoadStation.getRemainQuantity(), Const.RAW_GLASS_TASK_TYPE_DISPATCH);
|
//结束调度任务 修改工位状态(起始位）状态为103 RAW_GLASS_STATE_RUNNING 任务完成后将状态改为101 目标位新增一条数据，架子号为（起始位）
|
rawGlassStorageDetailsService.update(new LambdaUpdateWrapper<RawGlassStorageDetails>()
|
.eq(RawGlassStorageDetails::getSlot, loadStation.get(1)).eq(RawGlassStorageDetails::getState, Const.RAW_GLASS_STATE_IN)
|
.set(RawGlassStorageDetails::getState, Const.RAW_GLASS_STATE_RUNNING));
|
return Boolean.TRUE;
|
}
|
} else {
|
//todo:生成出库任务
|
rawGlassStorageDetailsService.generateTask(loadStation.get(1), twoLoadStation.getShelf(), twoLoadStation.getShelf(), twoLoadStation.getRemainQuantity(), Const.RAW_GLASS_TASK_TYPE_DISPATCH);
|
//结束调度任务 修改工位状态(起始位）状态为103 RAW_GLASS_STATE_RUNNING 任务完成后将状态改为101 目标位新增一条数据，架子号为（起始位）
|
rawGlassStorageDetailsService.update(new LambdaUpdateWrapper<RawGlassStorageDetails>()
|
.eq(RawGlassStorageDetails::getSlot, loadStation.get(1)).eq(RawGlassStorageDetails::getState, Const.RAW_GLASS_STATE_IN)
|
.set(RawGlassStorageDetails::getState, Const.RAW_GLASS_STATE_RUNNING));
|
return Boolean.TRUE;
|
}
|
}
|
// return Boolean.FALSE;
|
} else {
|
log.info("2号上片位仅剩空架子，1号上片位生成出库调度任务");
|
rawGlassStorageDetailsService.generateTask(loadStation.get(0), oneLoadStation.getShelf(), oneLoadStation.getShelf(), oneLoadStation.getRemainQuantity(), Const.RAW_GLASS_TASK_TYPE_DISPATCH);
|
rawGlassStorageDetailsService.update(new LambdaUpdateWrapper<RawGlassStorageDetails>()
|
.eq(RawGlassStorageDetails::getSlot, loadStation.get(0)).eq(RawGlassStorageDetails::getState, Const.RAW_GLASS_STATE_IN)
|
.set(RawGlassStorageDetails::getState, Const.RAW_GLASS_STATE_RUNNING));
|
return Boolean.TRUE;
|
}
|
} else {
|
log.info("1号上片位玻璃尺寸不一致，1号上片位生成出库调度任务");
|
rawGlassStorageDetailsService.generateTask(loadStation.get(0), oneLoadStation.getSlot(), oneLoadStation.getShelf(), oneLoadStation.getRemainQuantity(), Const.RAW_GLASS_TASK_TYPE_DISPATCH);
|
rawGlassStorageDetailsService.update(new LambdaUpdateWrapper<RawGlassStorageDetails>()
|
.eq(RawGlassStorageDetails::getSlot, loadStation.get(0)).eq(RawGlassStorageDetails::getState, Const.RAW_GLASS_STATE_IN)
|
.set(RawGlassStorageDetails::getState, Const.RAW_GLASS_STATE_RUNNING));
|
return Boolean.TRUE;
|
}
|
}
|
}
|
|
private RawGlassStorageDetails generateDetails(RawGlassStorageDetails details, Integer targetSlot) {
|
RawGlassStorageDetails targetDetails = new RawGlassStorageDetails();
|
RawGlassStorageStation station = rawGlassStorageStationService.getOne(new LambdaQueryWrapper<RawGlassStorageStation>()
|
.eq(RawGlassStorageStation::getSlot, targetSlot));
|
targetDetails.setDeviceId(station.getDeviceId());
|
targetDetails.setSlot(targetSlot);
|
targetDetails.setShelf(details.getShelf());
|
targetDetails.setPatternWidth(details.getPatternWidth());
|
targetDetails.setPatternHeight(details.getPatternHeight());
|
targetDetails.setPatternThickness(details.getPatternThickness());
|
targetDetails.setFilmsId(details.getFilmsId());
|
targetDetails.setRemainQuantity(details.getRemainQuantity());
|
targetDetails.setCreateTime(new Date());
|
targetDetails.setState(Const.RAW_GLASS_STATE_IN);
|
return targetDetails;
|
}
|
|
|
private ReadWriteEntity generateReadWriteEntity(String identifier, int value) {
|
ReadWriteEntity readWriteEntity = new ReadWriteEntity();
|
readWriteEntity.setIdentifier(identifier);
|
readWriteEntity.setValue(value);
|
return readWriteEntity;
|
}
|
|
private RawGlassStorageDetails getRawGlassStorageDetailsBySize(UpPattenUsageVO usageVO, int remainQuantity) {
|
return rawGlassStorageDetailsService.getOne(new LambdaQueryWrapper<RawGlassStorageDetails>()
|
.eq(RawGlassStorageDetails::getFilmsId, usageVO.getFilmsId())
|
.eq(RawGlassStorageDetails::getPatternWidth, usageVO.getWidth())
|
.eq(RawGlassStorageDetails::getPatternHeight, usageVO.getHeight())
|
.eq(RawGlassStorageDetails::getPatternThickness, usageVO.getThickness())
|
.eq(RawGlassStorageDetails::getState, Const.GLASS_STATE_IN)
|
.orderByAsc(RawGlassStorageDetails::getRemainQuantity)
|
.last("order by abs(t.remain_quantity - " + remainQuantity + ") asc")
|
.last("limit 1"));
|
}
|
|
/**
|
* 尺寸一样并且原片数量大于0
|
*
|
* @param upPattenUsage
|
* @param details
|
* @return
|
*/
|
private boolean compareRawSize(UpPattenUsage upPattenUsage, RawGlassStorageDetails details) {
|
boolean flag = upPattenUsage.getWidth() == details.getPatternWidth() && upPattenUsage.getHeight() == details.getPatternHeight() &&
|
upPattenUsage.getThickness() == details.getPatternThickness() && upPattenUsage.getFilmsId().equals(details.getFilmsId());
|
return flag;
|
}
|
|
}
|
