package com.mes.job;
|
|
import cn.hutool.core.lang.Assert;
|
import cn.smallbun.screw.core.util.CollectionUtils;
|
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
|
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
|
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
|
import com.mes.common.S7object;
|
import com.mes.common.config.Const;
|
import com.mes.device.PlcParameterObject;
|
import com.mes.downglassinfo.entity.DownGlassInfo;
|
import com.mes.downglassinfo.entity.DownGlassTask;
|
import com.mes.downglassinfo.service.DownGlassInfoService;
|
import com.mes.downglassinfo.service.DownGlassTaskService;
|
import com.mes.downstorage.entity.DownStorageCage;
|
import com.mes.downstorage.entity.DownStorageCageDetails;
|
import com.mes.downstorage.service.DownStorageCageDetailsService;
|
import com.mes.downstorage.service.DownStorageCageService;
|
import com.mes.downworkstation.entity.DownWorkstation;
|
import com.mes.downworkstation.entity.dto.DownGlassInfoDTO;
|
import com.mes.downworkstation.service.DownWorkstationService;
|
import com.mes.glassinfo.entity.GlassInfo;
|
import com.mes.glassinfo.service.GlassInfoService;
|
import com.mes.tools.S7control;
|
import lombok.extern.slf4j.Slf4j;
|
import org.apache.commons.lang.StringUtils;
|
import org.springframework.beans.BeanUtils;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.beans.factory.annotation.Value;
|
import org.springframework.scheduling.annotation.Scheduled;
|
import org.springframework.stereotype.Component;
|
|
import java.util.*;
|
import java.util.stream.Collectors;
|
|
/**
|
* @Author : zhoush
|
* @Date: 2024/5/8 8:17
|
* @Description:
|
*/
|
@Component
|
@Slf4j
|
public class DownLoadCacheGlassTask {
|
|
@Autowired
|
DownGlassTaskService downGlassTaskService;
|
@Autowired
|
GlassInfoService glassInfoService;
|
@Autowired
|
DownStorageCageDetailsService downStorageCageDetailsService;
|
@Autowired
|
DownStorageCageService downStorageCageService;
|
@Autowired
|
DownWorkstationService downWorkstationService;
|
@Autowired
|
DownGlassInfoService downGlassInfoService;
|
|
@Value("${mes.threshold}")
|
private Integer threshold;
|
|
@Value("${mes.throughWidth}")
|
private Integer throughWidth;
|
|
@Value("${mes.throughHeight}")
|
private Integer throughHeight;
|
|
@Value("${mes.maxWidth}")
|
private Integer maxWidth;
|
|
@Value("${mes.maxHeight}")
|
private Integer maxHeight;
|
|
@Value("${mes.minWidth}")
|
private Integer minWidth;
|
|
@Value("${mes.minHeight}")
|
private Integer minHeight;
|
|
|
@Scheduled(fixedDelay = 3000)
|
public void plcHomeEdgTask() {
|
PlcParameterObject plcParameterObject = S7object.getinstance().PlcMesObject;
|
String requestWord = plcParameterObject.getPlcParameter("requestWord").getValue();
|
String glassIdeValue = plcParameterObject.getPlcParameter("requestID").getValue();
|
//A08 A09表示线路相同 可做等价 无数据转int异常
|
String out06Glassstate = plcParameterObject.getPlcParameter("glassStatus06").getValue();
|
String out08Glassstate = plcParameterObject.getPlcParameter("glassStatus08").getValue();
|
String out11Glassstate = plcParameterObject.getPlcParameter("glassStatus11").getValue();
|
String out13Glassstate = plcParameterObject.getPlcParameter("glassStatus13").getValue();
|
String confirmationWrodValue = plcParameterObject.getPlcParameter("confirmationWord").getValue();
|
String confirmationWrodAddress = plcParameterObject.getPlcParameter("confirmationWord").getAddress();
|
String currentSlot = plcParameterObject.getPlcParameter("currentCell").getValue();
|
|
|
log.info("1、获取到的请求字为：{}，获取到的扫描ID为：{}，获取到的确认字为：{}，获取到的出片状态分别为：g06:{}、g08:{}、g11:{}、g13:{},当前格子号为：{}",
|
requestWord, glassIdeValue, confirmationWrodValue, out06Glassstate, out08Glassstate, out11Glassstate, out13Glassstate, currentSlot);
|
|
if ("0".equals(requestWord)) {
|
if ("0".equals(confirmationWrodValue)) {
|
log.info("2、获取到的请求字为0，且确认字为0，不执行任务");
|
return;
|
}
|
log.info("2、获取到的请求字为0，将确认字改为0");
|
S7object.getinstance().plccontrol.writeWord(confirmationWrodAddress, 0);
|
return;
|
}
|
if (!"0".equals(confirmationWrodValue)) {
|
log.info("2、获取到的请求字不为0，将确认字不为0，直接结束");
|
return;
|
}
|
if ("1".equals(requestWord)) {
|
log.info("2、进片请求，且确认字为0，执行进片任务");
|
inTo(glassIdeValue, requestWord, currentSlot);
|
} else if ("2".equals(requestWord)) {
|
//09空闲 ：1 10空闲 ：2 都空闲：3 其他0
|
log.info("2、出片请求，且确认字为0，执行出片任务");
|
outTo(out06Glassstate, out08Glassstate, out11Glassstate, out13Glassstate, glassIdeValue, currentSlot);
|
} else if ("3".equals(requestWord)) {
|
log.info("2、进片和出片都空闲，执行出片任务");
|
//加笼子里面是否有玻璃，有先出，无玻璃先进
|
boolean outFlase = outTo(out06Glassstate, out08Glassstate, out11Glassstate, out13Glassstate, glassIdeValue, currentSlot);
|
log.info("出片任务是否完成：{},失败且玻璃id:{}不为空则执行进片任务", outFlase, glassIdeValue);
|
if (!outFlase && StringUtils.isNotBlank(glassIdeValue)) {
|
inTo(glassIdeValue, requestWord, currentSlot);
|
}
|
}
|
}
|
|
public void inTo(String glassId, String requestWord, String currentSlot) {
|
log.info("1、按照玻璃id:{}获取玻璃小片信息,当前格子为:{}", glassId, currentSlot);
|
//添加进片任务 查找空格
|
DownStorageCage nearestEmpty = downStorageCageService.selectCacheEmpty(Integer.parseInt(currentSlot), Boolean.FALSE);
|
Assert.isTrue(null != nearestEmpty, "格子已满,无法执行进片操作");
|
log.info("2、查询卧式理片笼里面的空格:{}", nearestEmpty);
|
GlassInfo glassInfo = glassInfoService.getOne(new LambdaQueryWrapper<GlassInfo>().eq(GlassInfo::getGlassId, glassId));
|
Assert.isFalse(null == glassInfo, "玻璃信息不存在");
|
if ("1".equals(requestWord) && (glassInfo.getWidth() > throughWidth || glassInfo.getHeight() > throughHeight)) {
|
log.info("玻璃当前尺寸宽：{}，高：{}只能直通，当前进片任务需等待", glassInfo.getWidth(), glassInfo.getHeight());
|
return;
|
}
|
Boolean checkFlag = Boolean.FALSE;
|
//玻璃尺寸是否走人工下片
|
if (glassInfo.getWidth() > maxWidth || glassInfo.getHeight() > maxHeight || glassInfo.getWidth() < minWidth || glassInfo.getHeight() < minHeight) {
|
log.info("该玻璃尺寸不符合要求，需要走人工下片直接进片");
|
} else {
|
log.info("该玻璃尺寸非人工下片");
|
//获取该玻璃的流程卡是否已绑定架子
|
DownWorkstation one = downWorkstationService.getOne(new LambdaQueryWrapper<DownWorkstation>()
|
.eq(DownWorkstation::getLayer, glassInfo.getLayer())
|
.eq(DownWorkstation::getFlowCardId, glassInfo.getFlowCardId()));
|
Boolean isBind = Boolean.FALSE;
|
if (null != one) {
|
log.info("该流程卡已绑定架子");
|
isBind = Boolean.TRUE;
|
checkFlag = multilayerCheck(glassInfo, isBind);
|
}
|
if (!checkFlag && !isBind) {
|
log.info("该玻璃的流程卡未绑定架子，获取是否有空架子");
|
List<DownWorkstation> list = downWorkstationService.list(new LambdaQueryWrapper<DownWorkstation>()
|
.isNull(DownWorkstation::getFlowCardId).orderByDesc(DownWorkstation::getWorkstationId));
|
if (CollectionUtils.isNotEmpty(list)) {
|
log.info("有空架子,将流程卡与架子好绑定，执行进片任务 结束");
|
//绑定流程卡
|
downWorkstationService.updateFlowCardIdAndCount(glassInfo.getFlowCardId(), glassInfo.getLayer(), list.get(0).getWorkstationId());
|
checkFlag = Boolean.TRUE;
|
}
|
}
|
if (!checkFlag) {
|
log.info("无空架子,获取已绑定架子的流程卡信息,查看玻璃信息是否可被对调");
|
List<DownGlassInfoDTO> downGlassInfoDTOList = downGlassInfoService.queryWorkStationIsIn(Boolean.FALSE);
|
log.info("获取架子上已绑定流程卡落架的数量及未落架的玻璃数据：{}", downGlassInfoDTOList);
|
if (CollectionUtils.isEmpty(downGlassInfoDTOList)) {
|
log.info("已绑定流程卡均无未落架玻璃，请及时处理架子上的玻璃，清除流程卡,执行进片任务");
|
} else {
|
//替换玻璃信息
|
endLoop:
|
for (DownGlassInfoDTO e : downGlassInfoDTOList) {
|
List<GlassInfo> glassInfoList = e.getGlassInfoList();
|
Optional<GlassInfo> glassInfoTempOptional = glassInfoList.stream().filter(item -> item.getWidth() == glassInfo.getWidth() && item.getHeight() == glassInfo.getHeight()
|
&& item.getThickness() == glassInfo.getThickness() && item.getFilmsid().equals(glassInfo.getFilmsid()))
|
.findFirst();
|
if (glassInfoTempOptional.isPresent()) {
|
GlassInfo item = glassInfoTempOptional.get();
|
//玻璃是否为多层
|
checkFlag = multilayerCheck(item, Boolean.FALSE);
|
if (checkFlag) {
|
//玻璃替换 仅替换流程卡id及层数
|
String tempFlowCardId = item.getFlowCardId();
|
Integer tempLayer = item.getLayer();
|
String flowCardId = glassInfo.getFlowCardId();
|
Integer layer = glassInfo.getLayer();
|
log.info("替换流程卡信息,当前玻璃信息:{}的流程卡号{}及层数{},替换后玻璃信息:{}的流程卡号{}及层数{}",
|
item, glassInfo, flowCardId, layer, tempFlowCardId, tempLayer);
|
glassInfo.setFlowCardId(tempFlowCardId);
|
glassInfo.setLayer(tempLayer);
|
glassInfoService.updateById(glassInfo);
|
item.setFlowCardId(flowCardId);
|
item.setLayer(layer);
|
glassInfoService.updateById(item);
|
break endLoop;
|
}
|
}
|
}
|
}
|
}
|
}
|
//将任务插入理片笼详情表
|
DownStorageCageDetails downStorageCageDetails = new DownStorageCageDetails();
|
BeanUtils.copyProperties(glassInfo, downStorageCageDetails);
|
downStorageCageDetails.setState(Const.GLASS_STATE_IN);
|
downStorageCageDetails.setSlot(nearestEmpty.getSlot());
|
downStorageCageDetailsService.save(downStorageCageDetails);
|
|
// 生成进片任务
|
initDownGlassTask(glassInfo, 0, nearestEmpty.getSlot(), Const.GLASS_CACHE_TYPE_IN);
|
}
|
|
public Boolean outTo(String glassStatus06, String out08Glassstate, String glassStatus11, String
|
glassStatus13, String glassId, String currentSlot) {
|
if ("2".equals(glassStatus06) && "2".equals(glassStatus11) && "2".equals(glassStatus13)) {
|
log.info("G06、G11、G13分别为{},{}、{}非自动状态，无法出片", glassStatus06, glassStatus11, glassStatus13);
|
return Boolean.FALSE;
|
}
|
|
List<DownStorageCageDetails> tempList = downStorageCageDetailsService.list(new LambdaQueryWrapper<DownStorageCageDetails>()
|
.eq(DownStorageCageDetails::getState, Const.GLASS_STATE_IN));
|
//获取待进片玻璃
|
DownStorageCageDetails cageDetails = new DownStorageCageDetails();
|
if (StringUtils.isNotBlank(glassId)) {
|
GlassInfo glassInfo = glassInfoService.getOne(new LambdaQueryWrapper<GlassInfo>().eq(GlassInfo::getGlassId, glassId));
|
BeanUtils.copyProperties(glassInfo, cageDetails);
|
//获取当前笼子空格信息
|
DownStorageCage empty = downStorageCageService.selectCacheEmpty(Integer.parseInt(currentSlot), Boolean.TRUE);
|
cageDetails.setSlot(empty.getSlot());
|
tempList.add(cageDetails);
|
}
|
|
log.info("笼内玻璃的数据有：{}", tempList);
|
if (CollectionUtils.isEmpty(tempList)) {
|
log.info("笼内没有玻璃,无法执行出片");
|
return Boolean.FALSE;
|
}
|
Boolean flag08 = "1".equals(out08Glassstate) ? Boolean.TRUE : Boolean.FALSE;
|
if (!generateTaskByShelf(glassStatus06, glassStatus11, flag08, glassStatus13, tempList, cageDetails, glassId)) {
|
return generateTaskByShelf(glassStatus06, glassStatus11, !flag08, glassStatus13, tempList, cageDetails, glassId);
|
}
|
return Boolean.TRUE;
|
}
|
|
private Boolean multilayerCheck(GlassInfo glassInfo, boolean isBind) {
|
//查询该流程卡是否为多层
|
if (glassInfo.getTotalLayer() > 1) {
|
log.info("按照流程卡获取当前流程卡各层已落架数量");
|
DownGlassInfoDTO downGlassInfoDTO = downGlassInfoService.queryDownGlassMaxLayer(glassInfo.getFlowCardId());
|
if (null == downGlassInfoDTO) {
|
if (isBind) {
|
return Boolean.TRUE;
|
} else {
|
log.info("架子已经占满，多层玻璃无法找到对应的格子，需执行替换玻璃的操作");
|
return Boolean.FALSE;
|
}
|
|
}
|
if (downGlassInfoDTO.getLayer().equals(glassInfo.getLayer())) {
|
log.info("当前玻璃的流程在架子上落架最多 直接进片");
|
return Boolean.TRUE;
|
}
|
Integer sequence = downGlassInfoService.queryMaxSequence(glassInfo.getFlowCardId(), glassInfo.getLayer());
|
log.info("获取当前玻璃需要放的次序：笼内同流程 同层数的通达次序+1:{}", sequence);
|
DownGlassInfo downGlassInfo = downGlassInfoService.getOne(new LambdaQueryWrapper<DownGlassInfo>()
|
.eq(DownGlassInfo::getFlowCardId, downGlassInfoDTO.getFlowCardId())
|
.eq(DownGlassInfo::getLayer, downGlassInfoDTO.getLayer()).eq(DownGlassInfo::getSequence, sequence));
|
log.info("拿当前版序获取玻璃信息{}，按照次序判断当前玻璃是否尺寸对应的上（与数量最多的次序比较）。", downGlassInfo);
|
if (null != downGlassInfoDTO && downGlassInfo.getWidth() == glassInfo.getWidth() && downGlassInfo.getHeight() == glassInfo.getHeight()) {
|
log.info("相同次序玻璃对应上，可执行进片任务");
|
return Boolean.TRUE;
|
} else {
|
log.info("同次序玻璃对应不上，需执行替换玻璃的操作");
|
return Boolean.FALSE;
|
}
|
} else {
|
log.info("非多层玻璃，直接进片");
|
return Boolean.TRUE;
|
}
|
}
|
|
private Boolean generateTaskByShelf(String glassStatus06, String glassStatus11, Boolean flag08, String
|
glassStatus13, List<DownStorageCageDetails> tempList, DownStorageCageDetails cageDetails, String glassId) {
|
//获取2个机械臂范围内的架子绑定的流程卡信息
|
List<Integer> workList = new ArrayList();
|
|
if (flag08) {
|
if (!"2".equals(glassStatus11)) {
|
workList.addAll(Const.G11_WORK_STATION);
|
}
|
} else {
|
if (!"2".equals(glassStatus06)) {
|
workList.addAll(Const.G06_WORK_STATION);
|
}
|
}
|
List<DownStorageCageDetails> list = new ArrayList();
|
Boolean isEmptyShelf = Boolean.FALSE;
|
//对笼内玻璃进行过滤，仅出符合逻辑的玻璃
|
if (CollectionUtils.isNotEmpty(workList)) {
|
List<DownWorkstation> downWorkstationList = downWorkstationService.list(new LambdaQueryWrapper<DownWorkstation>()
|
.eq(DownWorkstation::getEnableState, Const.SLOT_ON).in(DownWorkstation::getWorkstationId, workList));
|
log.info("架子被禁用，无法出片落架");
|
if (CollectionUtils.isEmpty(downWorkstationList)) {
|
log.info("笼子被禁用，无法走机械臂下片");
|
//走人工下片
|
if (!"2".equals(glassStatus13)) {
|
list = tempList.stream().filter(item -> item.getWidth() > maxWidth || item.getHeight() > maxHeight).collect(Collectors.toList());
|
}
|
} else {
|
List<DownWorkstation> workstationsIsNotBind = downWorkstationList.stream().filter(item -> null == (item.getFlowCardId())).collect(Collectors.toList());
|
Map<String, List<DownWorkstation>> listMap = downWorkstationList.stream().collect(Collectors.groupingBy(item -> item.getFlowCardId() + ":" + item.getLayer()));
|
if (CollectionUtils.isEmpty(workstationsIsNotBind)) {
|
log.info("不存在未绑定流程卡架子");
|
//筛选出对应架子已绑定流程卡可下片的玻璃
|
list = tempList.stream().filter(item -> listMap.containsKey(item.getFlowCardId() + ":" + item.getLayer())).collect(Collectors.toList());
|
} else {
|
log.info("存在未绑定流程卡架子，直接获取笼内所有玻璃");
|
isEmptyShelf = Boolean.TRUE;
|
//todo:如果禁用架子已绑定流程卡，因为时间不确定，笼子内的玻璃可重新绑定新架子
|
// list = tempList.stream().filter(item -> !listMap.containsKey(item.getFlowCardId() + ":" + item.getLayer())).collect(Collectors.toList());
|
list = tempList;
|
}
|
}
|
} else {
|
if (flag08 && !"2".equals(glassStatus13)) {
|
//直接走人工下片
|
list = tempList.stream().filter(item -> item.getWidth() > maxWidth || item.getHeight() > maxHeight).collect(Collectors.toList());
|
}
|
}
|
if (CollectionUtils.isEmpty(list)) {
|
log.info("笼内玻璃无法执行出片");
|
return Boolean.FALSE;
|
}
|
String tempGlassId = null;
|
Boolean isBind = Boolean.FALSE;
|
|
for (DownStorageCageDetails item : list) {
|
if (item.getWidth() > maxWidth || item.getHeight() > maxHeight) {
|
if (flag08 && !"2".equals(glassStatus13)) {
|
log.info("玻璃宽度或高度超出阈值，执行人工下片");
|
tempGlassId = item.getGlassId();
|
break;
|
}
|
}
|
}
|
loop:
|
if (tempGlassId == null) {
|
//获取正在落架的绑定流程卡的信息(流程卡、层数、落架数量)
|
List<DownGlassInfoDTO> downGlassInfoDTOList = downGlassInfoService.queryWorkStationIsIn(Boolean.TRUE);
|
List<String> downGlassFlowList = downGlassInfoDTOList.stream().map(item -> item.getFlowCardId() + ":" + item.getLayer()).collect(Collectors.toList());
|
if (CollectionUtils.isEmpty(downGlassFlowList)) {
|
//架子都未绑定流程卡，出笼内子数量最多尺寸最大的玻璃id,无 则返回扫描扫到的玻璃id进行出片
|
tempGlassId = downStorageCageDetailsService.getGlassInfoMaxCount(glassId);
|
isBind = Boolean.TRUE;
|
break loop;
|
}
|
//将笼子内的玻璃进行过滤，仅获取无法落架的流程卡玻璃
|
List<DownStorageCageDetails> noDownLoadList = list.stream().filter(item -> !downGlassFlowList.contains(item.getFlowCardId() + ":" + item.getLayer())).collect(Collectors.toList());
|
if (CollectionUtils.isNotEmpty(noDownLoadList)) {
|
//是否有空架子
|
// List<DownWorkstation> emptyShelfList = downWorkstationService.list(new LambdaQueryWrapper<DownWorkstation>()
|
// .isNull(DownWorkstation::getFlowCardId));
|
if (isEmptyShelf) {
|
//架子都未绑定流程卡，出笼内子数量最多尺寸最大的玻璃id,无 则返回扫描扫到的玻璃id进行出片
|
tempGlassId = downStorageCageDetailsService.getGlassInfoMaxCount(glassId);
|
isBind = Boolean.TRUE;
|
break loop;
|
}
|
}
|
//将笼子内的玻璃进行过滤，仅获取可落架的流程卡玻璃
|
List<DownStorageCageDetails> downLoadList = list.stream().filter(item -> downGlassFlowList.contains(item.getFlowCardId() + ":" + item.getLayer())).collect(Collectors.toList());
|
if (CollectionUtils.isEmpty(downLoadList)) {
|
//不执行出片任务，笼内没有合适的出片玻璃
|
return Boolean.FALSE;
|
}
|
//将笼内玻璃的流程卡+层号 和落架的流程卡 去重，得出展示无法落架的玻璃，判断玻璃数是否超过阈值
|
//笼内玻璃是否可落架:笼内是否有需要中空的
|
List<DownStorageCageDetails> multiLayerList = list.stream().filter(item -> item.getTotalLayer() >= 2).collect(Collectors.toList());
|
if (CollectionUtils.isNotEmpty(multiLayerList)) {
|
for (DownStorageCageDetails item : multiLayerList) {
|
DownGlassInfoDTO downGlassInfoDTO = downGlassInfoService.queryDownGlassMaxLayer(item.getFlowCardId());
|
if (null == downGlassInfoDTO) {
|
// 历史落架玻璃按照相关流程卡取数据库未找到最多玻璃信息，表明当前流程卡下的有层的玻璃均未落架，直接可出当前玻璃
|
log.info("");
|
isBind = Boolean.FALSE;
|
tempGlassId = item.getGlassId();
|
break loop;
|
}
|
if (downGlassInfoDTO.getLayer().equals(downGlassInfoDTO.getLayer())) {
|
log.info("当前玻璃的流程在架子上落架最多,直接出片");
|
//更新玻璃状态，生成出片任务
|
tempGlassId = item.getGlassId();
|
isBind = Boolean.FALSE;
|
break loop;
|
}
|
Integer sequence = downGlassInfoService.queryMaxSequence(item.getFlowCardId(), item.getLayer());
|
log.info("获取当前玻璃需要放的次序：笼内同流程 同层数的通达次序+1:{}", sequence);
|
DownGlassInfo downGlassInfo = downGlassInfoService.getOne(new LambdaQueryWrapper<DownGlassInfo>()
|
.eq(DownGlassInfo::getFlowCardId, downGlassInfoDTO.getFlowCardId())
|
.eq(DownGlassInfo::getLayer, downGlassInfoDTO.getLayer()).eq(DownGlassInfo::getSequence, sequence));
|
if (null != downGlassInfoDTO && downGlassInfo.getWidth() == item.getWidth() && downGlassInfo.getHeight() == item.getHeight()) {
|
log.info("相同次序玻璃对应上，可执行进片任务");
|
//更新玻璃状态，生成出片任务
|
tempGlassId = item.getGlassId();
|
isBind = Boolean.FALSE;
|
break loop;
|
}
|
}
|
}
|
|
Map<String, List<DownStorageCageDetails>> singleLayerMap = list.stream().filter(item -> item.getTotalLayer() == 1)
|
.collect(Collectors.groupingBy(item -> item.getFlowCardId() + item.getLayer(), Collectors.toList()));
|
if (tempGlassId == null) {
|
if (CollectionUtils.isNotEmpty(singleLayerMap)) {
|
//获取已落架流程卡信息，按落架数量排序
|
for (DownGlassInfoDTO e : downGlassInfoDTOList) {
|
List<DownStorageCageDetails> downStorageCageDetails = singleLayerMap.get(e.getFlowCardId() + e.getLayer());
|
if (CollectionUtils.isNotEmpty(downStorageCageDetails)) {
|
tempGlassId = downStorageCageDetails.get(0).getGlassId();
|
isBind = Boolean.FALSE;
|
break;
|
}
|
}
|
}
|
}
|
}
|
if (tempGlassId == null) {
|
log.info("没有找到可以下片的的玻璃，结束任务");
|
return Boolean.FALSE;
|
} else {
|
//按照出片的玻璃id更新笼内的玻璃状态为已出片
|
return generateDownGlassOutTask(tempGlassId, Const.GLASS_CACHE_TYPE_OUT, isBind, cageDetails);
|
}
|
}
|
|
public Boolean generateDownGlassOutTask(String glassId, Integer taskType, Boolean
|
isBind, DownStorageCageDetails cageDetails) {
|
//按玻璃id获取玻璃信息
|
DownStorageCageDetails downStorageCageDetails = null;
|
if (glassId.equals(cageDetails.getGlassId())) {
|
downStorageCageDetails = cageDetails;
|
taskType = 3;
|
} else {
|
downStorageCageDetails = downStorageCageDetailsService.getOne(new LambdaQueryWrapper<DownStorageCageDetails>()
|
.eq(DownStorageCageDetails::getGlassId, glassId).eq(DownStorageCageDetails::getState, Const.GLASS_STATE_IN));
|
}
|
|
Integer endCell = null;
|
if (isBind) {
|
//获取空架子信息，将空架子信息绑定流程卡
|
DownWorkstation emptyDownWorkstation = downWorkstationService.getOne(new LambdaQueryWrapper<DownWorkstation>()
|
.isNull(DownWorkstation::getFlowCardId).orderByDesc(DownWorkstation::getWorkstationId).last("limit 1"));
|
if (null != emptyDownWorkstation) {
|
log.info("获取到空架子信息，绑定流程卡");
|
downWorkstationService.updateFlowCardIdAndCount(downStorageCageDetails.getFlowCardId(), downStorageCageDetails.getLayer(), emptyDownWorkstation.getWorkstationId());
|
endCell = emptyDownWorkstation.getWorkstationId();
|
} else {
|
log.info("没有空架子信息，无法绑定流程卡");
|
return Boolean.FALSE;
|
}
|
} else {
|
DownWorkstation workstation = downWorkstationService.getOne(new LambdaUpdateWrapper<DownWorkstation>()
|
.eq(DownWorkstation::getFlowCardId, downStorageCageDetails.getFlowCardId()).eq(DownWorkstation::getLayer, downStorageCageDetails.getLayer()));
|
endCell = workstation.getWorkstationId();
|
}
|
//更新详情表内的状态
|
if (downStorageCageDetailsService.update(new LambdaUpdateWrapper<DownStorageCageDetails>()
|
.set(DownStorageCageDetails::getState, Const.GLASS_STATE_OUT).eq(DownStorageCageDetails::getGlassId, glassId))) {
|
log.info("更新详情表内的状态成功");
|
} else {
|
log.info("更新详情表内的状态失败");
|
return Boolean.FALSE;
|
}
|
//更新落架玻璃数量
|
if (endCell == 7) {
|
downWorkstationService.update(new UpdateWrapper<DownWorkstation>().eq("flow_card_id", downStorageCageDetails.getFlowCardId())
|
.eq("layer", downStorageCageDetails.getLayer()).setSql("other_number = other_number +1"));
|
} else {
|
downWorkstationService.update(new UpdateWrapper<DownWorkstation>().eq("flow_card_id", downStorageCageDetails.getFlowCardId())
|
.eq("layer", downStorageCageDetails.getLayer()).setSql("racks_number = racks_number +1"));
|
}
|
|
//生成任务信息
|
DownGlassInfo downGlassInfo = new DownGlassInfo();
|
BeanUtils.copyProperties(downStorageCageDetails, downGlassInfo);
|
downGlassInfoService.save(downGlassInfo);
|
//生成任务信息
|
GlassInfo glassInfo = new GlassInfo();
|
BeanUtils.copyProperties(downStorageCageDetails, glassInfo);
|
return initDownGlassTask(glassInfo, downStorageCageDetails.getSlot(), endCell, taskType);
|
}
|
|
public Boolean initDownGlassTask(GlassInfo glassInfo, Integer startCell, Integer endCell, Integer taskType) {
|
log.info("玻璃{}生成进片任务", glassInfo.getGlassId());
|
DownGlassTask downGlassTask = new DownGlassTask();
|
downGlassTask.setStartCell(startCell);
|
downGlassTask.setGlassId(glassInfo.getGlassId());
|
downGlassTask.setEndCell(endCell);
|
downGlassTask.setTaskType(taskType);
|
downGlassTask.setWidth((int) glassInfo.getWidth());
|
downGlassTask.setHeight((int) glassInfo.getHeight());
|
downGlassTask.setFlowCardId(glassInfo.getFlowCardId());
|
downGlassTask.setLayer(glassInfo.getLayer());
|
downGlassTask.setTaskStatus(0);
|
downGlassTask.setCreateTime(new Date());
|
downGlassTaskService.save(downGlassTask);
|
//向plc发送命令
|
return sendMessageToPlc((int) glassInfo.getWidth(), (int) glassInfo.getHeight(), (int) glassInfo.getThickness(),
|
startCell, endCell, taskType);
|
}
|
|
private Boolean sendMessageToPlc(int width, int height, int thickness, int startCell, int endCell,
|
int taskType) {
|
S7control s7control = S7object.getinstance().plccontrol;
|
PlcParameterObject plcMesObject = S7object.getinstance().PlcMesObject;
|
s7control.writeWord(plcMesObject.getPlcParameter("Glass_width").getAddress(), width);
|
s7control.writeWord(plcMesObject.getPlcParameter("Glass_height").getAddress(), height);
|
s7control.writeWord(plcMesObject.getPlcParameter("Glass_thickness").getAddress(), thickness);
|
s7control.writeWord(plcMesObject.getPlcParameter("Start_cell").getAddress(), startCell);
|
s7control.writeWord(plcMesObject.getPlcParameter("End_cell").getAddress(), endCell);
|
s7control.writeWord(plcMesObject.getPlcParameter("task_type").getAddress(), taskType);
|
s7control.writeWord(plcMesObject.getPlcParameter("confirmationWord").getAddress(), 1);
|
return Boolean.TRUE;
|
}
|
}
|
