package com.mes.job; import cn.hutool.core.collection.CollectionUtil; import cn.hutool.core.lang.Assert; import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper; import com.github.xingshuangs.iot.protocol.s7.serializer.S7Serializer; import com.github.yulichang.toolkit.JoinWrappers; import com.kangaroohy.milo.model.ReadWriteEntity; import com.kangaroohy.milo.service.MiloService; import com.mes.base.entity.BigStorageCageBaseInfo; import com.mes.bigstorage.entity.BigStorageCage; import com.mes.bigstorage.entity.BigStorageCageDetails; import com.mes.bigstorage.entity.dto.BigStorageDTO; import com.mes.bigstorage.entity.dto.BigStorageRelationDTO; import com.mes.bigstorage.entity.dto.BigStorageSequenceDTO; import com.mes.bigstorage.entity.dto.TemperingLayoutDTO; import com.mes.bigstorage.service.BigStorageCageDetailsService; import com.mes.bigstorage.service.BigStorageCageService; import com.mes.bigstorage.service.BigStorageGlassInfoService; import com.mes.bigstorage.service.BigStorageGlassRelationInfoService; import com.mes.bigstoragecagetask.entity.BigStorageCageHistoryTask; import com.mes.bigstoragecagetask.entity.BigStorageCageTask; import com.mes.bigstoragecagetask.service.BigStorageCageHistoryTaskService; import com.mes.bigstoragecagetask.service.BigStorageCageTaskService; import com.mes.bigstoragetask.entity.UpdateBigStorageCageDTO; import com.mes.common.config.Const; import com.mes.common.config.ConstSysConfig; import com.mes.damage.entity.Damage; import com.mes.damage.service.DamageService; import com.mes.edgglasstask.entity.EdgGlassTaskInfo; import com.mes.edgglasstask.service.EdgGlassTaskInfoService; import com.mes.glassinfo.entity.GlassInfo; import com.mes.glassinfo.service.GlassInfoService; import com.mes.s7.entity.S7DataDLPOne; import com.mes.s7.entity.S7DataDLPTwo; import com.mes.sysconfig.service.SysConfigService; import com.mes.temperingglass.entity.TemperingGlassInfo; import com.mes.temperingglass.service.TemperingGlassInfoService; import com.mes.utils.RedisUtil; 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.Qualifier; import org.springframework.scheduling.annotation.Scheduled; import org.springframework.stereotype.Component; import javax.annotation.Resource; import java.util.*; import java.util.stream.Collectors; /** * @author SNG-015 */ @Component @Slf4j public class OpcPlcStorageCageNewTask { @Resource private BigStorageCageDetailsService bigStorageCageDetailsService; @Resource private TemperingGlassInfoService temperingGlassInfoService; @Resource private DamageService damageService; @Resource private GlassInfoService glassInfoService; @Resource private BigStorageGlassRelationInfoService bigStorageGlassRelationInfoService; @Resource private BigStorageCageService bigStorageCageService; @Resource private BigStorageCageHistoryTaskService bigStorageCageHistoryTaskService; @Resource private BigStorageCageTaskService bigStorageCageTaskService; @Resource private BigStorageGlassInfoService bigStorageGlassInfoService; @Resource private EdgGlassTaskInfoService edgGlassTaskInfoService; @Autowired(required = false) MiloService miloService; @Autowired @Qualifier("s7SerializerDLPOne") private S7Serializer s7SerializerDLPOne; @Autowired @Qualifier("s7SerializerDLPTwo") private S7Serializer s7SerializerDLPTwo; @Resource SysConfigService sysConfigService; /** * 直通格子 */ private static final Integer THROUGH_SLOT = 920; @Resource private RedisUtil redisUtil; @Scheduled(fixedDelay = 1000) public void inBigStorageTask() throws Exception { S7DataDLPOne s7DataDLPOne = s7SerializerDLPOne.read(S7DataDLPOne.class); // ReadWriteEntity inkageEntity = miloService.readFromOpcUa("DLP1A.DLP1A.mesControl"); // if (true != Boolean.parseBoolean(inkageEntity.getValue() + "")) { Boolean inkageEntity = s7DataDLPOne.getMesControl(); if (true != inkageEntity) { log.info("当前为非联机状态，结束进片任务"); return; } // ReadWriteEntity requestEntity = miloService.readFromOpcUa("DLP1A.DLP1A.RequestMes"); // if (!"1".equals(requestEntity.getValue() + "")) { String requestEntity = s7DataDLPOne.getRequestMes().toString(); if (!"1".equals(requestEntity)) { log.info("当前未收到进片请求，结束进片任务"); return; } // ReadWriteEntity mesReplyEntity = miloService.readFromOpcUa("DLP1A.DLP1A.MesReply"); // if ("1".equals(mesReplyEntity.getValue() + "")) { String mesReplyEntity = s7DataDLPOne.getMesReply().toString(); if ("1".equals(mesReplyEntity)) { log.info("有正在执行的任务，结束进片任务"); return; } //获取进片任务信息 List inTaskList = new ArrayList(); // ReadWriteEntity fromOpcUa = miloService.readFromOpcUa("DLP1A.DLP1A.FROM1"); String fromOpcUa = s7DataDLPOne.getFrom1().toString(); List ids = s7DataDLPOne.getIds(); List glassIdList = new ArrayList<>(); for (int i = 0; i < 6; i++) { // ReadWriteEntity requestWord = miloService.readFromOpcUa("DLP1A.DLP1A.DI" + i); String requestWord = ids.get(i); // if (null != requestWord.getValue()) { if (null != requestWord && !requestWord.isEmpty()) { BigStorageCageTask task = new BigStorageCageTask(); // task.setGlassId(requestWord.getValue() + ""); task.setGlassId(requestWord); // task.setStartSlot(Integer.parseInt(fromOpcUa.getValue() + "")); task.setStartSlot(Integer.parseInt(fromOpcUa)); inTaskList.add(task); // glassIdList.add(requestWord.getValue() + ""); glassIdList.add(requestWord); continue; } } if (CollectionUtil.isEmpty(inTaskList)) { log.info("当前大车无进片玻璃，结束进片任务"); return; } log.info("获取任务的玻璃id：{}", glassIdList); // ReadWriteEntity countEntity = miloService.readFromOpcUa("DLP1A.DLP1A.glassCount"); String countEntity = s7DataDLPOne.getGlassCount().toString(); // if (null == countEntity.getValue() || Integer.parseInt(countEntity.getValue() + "") != glassIdList.size()) { if (null == countEntity || Integer.parseInt(countEntity) != glassIdList.size()) { log.info("当前大车进片玻璃数量{}与mes读取到的数量{}不匹配，结束进片任务", countEntity, glassIdList.size()); //向plc发送报警:当前大车进片玻璃数量与mes读取到的数量不匹配 // miloService.writeToOpcWord(generateReadWriteEntity("DLP1A.DLP1A.alarmSignal", 1)); s7DataDLPOne = new S7DataDLPOne(); s7DataDLPOne.setAlarmSignal(1); s7SerializerDLPOne.write(s7DataDLPOne); return; } Map glassCountMap = glassIdList.stream().collect(Collectors.groupingBy(e -> e, Collectors.counting())); for (Map.Entry entry : glassCountMap.entrySet()) { if (entry.getValue() > 1) { log.info("进片玻璃{}存在相同，结束本次任务", entry.getKey()); //向plc发送报警:同一车进片玻璃存在相同 // miloService.writeToOpcWord(generateReadWriteEntity("DLP1A.DLP1A.alarmSignal", 2)); s7DataDLPOne = new S7DataDLPOne(); s7DataDLPOne.setAlarmSignal(2); s7SerializerDLPOne.write(s7DataDLPOne); return; } } List detailsList = bigStorageCageDetailsService.list(new LambdaQueryWrapper().in(BigStorageCageDetails::getGlassId, glassIdList) .in(BigStorageCageDetails::getState, Const.GLASS_STATE_IN_ALL_ZERO)); if (CollectionUtil.isNotEmpty(detailsList)) { log.info("理片笼存在相同的进片玻璃{}，结束本次任务", detailsList); //向plc发送报警:理片笼存在相同的进片玻璃 // miloService.writeToOpcWord(generateReadWriteEntity("DLP1A.DLP1A.alarmSignal", 4)); s7DataDLPOne = new S7DataDLPOne(); s7DataDLPOne.setAlarmSignal(4); s7SerializerDLPOne.write(s7DataDLPOne); return; } List glassInfoList = glassInfoService.list(new LambdaQueryWrapper().in(GlassInfo::getGlassId, glassIdList)); if (glassInfoList.size() != inTaskList.size()) { log.info("进片任务数量{}与玻璃数量{}不匹配，结束本次进片", inTaskList.size(), glassInfoList.size()); //向plc发送报警:进片任务数量与系统查询到的玻璃数量不匹配 // miloService.writeToOpcWord(generateReadWriteEntity("DLP1A.DLP1A.alarmSignal", 8)); s7DataDLPOne = new S7DataDLPOne(); s7DataDLPOne.setAlarmSignal(8); s7SerializerDLPOne.write(s7DataDLPOne); return; } Integer glassGap = sysConfigService.queryConfigValue(ConstSysConfig.VERTICAL_GLASS_GAP); Integer slotMaxthickness = sysConfigService.queryConfigValue(ConstSysConfig.VERTICAL_SLOT_MAX_THICKNESS); Integer slotWidth = sysConfigService.queryConfigValue(ConstSysConfig.VERTICAL_SLOT_WIDTH); Integer slotMaxHeight = sysConfigService.queryConfigValue(ConstSysConfig.VERTICAL_SLOT_MAX_HEIGHT); //按照玻璃厚度分组，判断剩余格子是否可以存放 Map thickCountMap = glassInfoList.stream().collect(Collectors.groupingBy(GlassInfo::getThickness, Collectors.counting())); if (glassInfoList.get(0).getThickness() < slotMaxthickness) { for (Map.Entry entry : thickCountMap.entrySet()) { int count = bigStorageCageService.count(new LambdaQueryWrapper() .eq(BigStorageCage::getEnableState, Const.SLOT_ON).eq(BigStorageCage::getRemainWidth, slotWidth) .le(BigStorageCage::getMinThickness, entry.getKey()) .ge(BigStorageCage::getMaxThickness, entry.getKey())); if (count < entry.getValue()) { log.info("笼内格子剩余数量不足，结束本次进片"); //向plc发送报警:笼内格子剩余数量不足 // miloService.writeToOpcWord(generateReadWriteEntity("DLP1A.DLP1A.alarmSignal", 16)); s7DataDLPOne = new S7DataDLPOne(); s7DataDLPOne.setAlarmSignal(16); s7SerializerDLPOne.write(s7DataDLPOne); return; } } } //超大尺寸 if (slotMaxHeight < Math.min(glassInfoList.get(0).getWidth(), glassInfoList.get(0).getHeight()) || glassInfoList.get(0).getThickness() >= slotMaxthickness) { int count = bigStorageCageDetailsService.count(new LambdaQueryWrapper() .eq(BigStorageCageDetails::getSlot, THROUGH_SLOT) .in(BigStorageCageDetails::getState, Const.GLASS_STATE_IN_ALL)); if (count > 0) { log.info("直通片台存在玻璃，结束本次进片"); //向plc发送报警:直通片台存在玻璃，无法继续直通 // miloService.writeToOpcWord(generateReadWriteEntity("DLP1A.DLP1A.alarmSignal", 64)); s7DataDLPOne = new S7DataDLPOne(); s7DataDLPOne.setAlarmSignal(64); s7SerializerDLPOne.write(s7DataDLPOne); return; } } //修改磨边对列表的玻璃状态 edgGlassTaskInfoService.update(new LambdaUpdateWrapper() .set(EdgGlassTaskInfo::getState, Const.EDG_GLASS_SUCCESS).in(EdgGlassTaskInfo::getGlassId, glassIdList)); //报工 for (String glass : glassIdList) { damageService.autoSubmitReport(glass, inTaskList.get(0).getStartSlot(), "磨边", "进大理片笼", 1); } Map> glassListMap = glassInfoList.stream().collect(Collectors.groupingBy(GlassInfo::getGlassId)); //计算目标格子 List historyTasks = new ArrayList<>(); //超大尺寸与正常尺寸玻璃计算方式不一样 if (slotMaxHeight > Math.min(glassInfoList.get(0).getWidth(), glassInfoList.get(0).getHeight()) && glassInfoList.get(0).getThickness() < slotMaxthickness) { for (BigStorageCageTask task : inTaskList) { GlassInfo info = glassListMap.get(task.getGlassId()).get(0); BigStorageDTO bigStorageDTO = bigStorageGlassInfoService.queryBigStorageTargetSlot(info.getEngineerId(), info.getTemperingLayoutId(), info.getTemperingFeedSequence()); //获取目标格子信息 // BigStorageDTO bigStorageDTO = bigStorageCageDetailsService.queryTargetSlotByTempering(info); // 临时更新格子的剩余尺寸：防止相邻玻璃进同一格子造成剩余尺寸不足，玻璃越界的情况，任务完成后再次更新大理片笼表剩余宽度（按照笼内玻璃数量更新大理片笼剩余尺寸） bigStorageCageService.update(new LambdaUpdateWrapper() .set(BigStorageCage::getRemainWidth, bigStorageDTO.getWidth() - Math.max(info.getWidth(), info.getHeight()) - glassGap) .eq(BigStorageCage::getSlot, bigStorageDTO.getSlot())); task.setTargetSlot(bigStorageDTO.getSlot()); task.setGlassId(info.getGlassId()); // bigStorageCageTaskService.updateTaskMessage("big_storage_cage_in_one_task", task); //存放历史任务 BigStorageCageHistoryTask historyTask = new BigStorageCageHistoryTask(); BeanUtils.copyProperties(task, historyTask); historyTask.setTaskType(Const.BIG_STORAGE_BEFORE_IN); historyTask.setGlassCount(glassInfoList.size()); historyTask.setTaskState(Const.ENGINEERING_NEW); historyTasks.add(historyTask); BigStorageCageDetails cageDetails = new BigStorageCageDetails(); BeanUtils.copyProperties(info, cageDetails); cageDetails.setSlot(bigStorageDTO.getSlot()); cageDetails.setState(Const.GLASS_STATE_NEW); cageDetails.setDeviceId(bigStorageDTO.getDeviceId()); cageDetails.setSequence(bigStorageDTO.getSlotSequence()); cageDetails.setAngle((int) info.getAngle()); cageDetails.setGap(glassGap); cageDetails.setFilmsId(info.getFilmsid()); cageDetails.setId(null); bigStorageCageDetailsService.save(cageDetails); } } else { BigStorageCageTask task = inTaskList.get(0); task.setTargetSlot(THROUGH_SLOT); // bigStorageCageTaskService.updateTaskMessage("big_storage_cage_in_one_task", task); //存放历史任务 BigStorageCageHistoryTask historyTask = new BigStorageCageHistoryTask(); BeanUtils.copyProperties(task, historyTask); historyTask.setTaskType(Const.BIG_STORAGE_BEFORE_IN); historyTask.setGlassCount(glassInfoList.size()); historyTask.setTaskState(Const.ENGINEERING_NEW); historyTasks.add(historyTask); GlassInfo info = glassInfoList.get(0); BigStorageCageDetails cageDetails = new BigStorageCageDetails(); BeanUtils.copyProperties(info, cageDetails); cageDetails.setSlot(THROUGH_SLOT); cageDetails.setState(Const.GLASS_STATE_NEW); cageDetails.setDeviceId(0); cageDetails.setSequence(0); cageDetails.setGap(glassGap); cageDetails.setAngle((int) info.getAngle()); cageDetails.setFilmsId(info.getFilmsid()); cageDetails.setId(null); bigStorageCageDetailsService.save(cageDetails); } //历史数据入库 bigStorageCageHistoryTaskService.saveBatch(historyTasks); //向opc发送启动信号 // List list = new ArrayList<>(); // for (int i = 1; i <= inTaskList.size(); i++) { // list.add(generateReadWriteEntity("DLP1A.DLP1A.TO" + i, inTaskList.get(i - 1).getTargetSlot())); // } // list.add(generateReadWriteEntity("DLP1A.DLP1A.MesReply", 1)); // miloService.writeToOpcWord(list); s7DataDLPOne = new S7DataDLPOne(); for (int i = 0; i < inTaskList.size(); i++) { Integer value = Integer.parseInt(inTaskList.get(i).getTargetSlot().toString()); switch (i) { case 0: s7DataDLPOne.setTo1(value); break; case 1: s7DataDLPOne.setTo2(value); break; case 2: s7DataDLPOne.setTo3(value); break; case 3: s7DataDLPOne.setTo4(value); break; case 4: s7DataDLPOne.setTo5(value); break; case 5: s7DataDLPOne.setTo6(value); break; } } s7SerializerDLPOne.write(s7DataDLPOne); s7DataDLPOne = new S7DataDLPOne(); s7DataDLPOne.setMesReply(1); s7SerializerDLPOne.write(s7DataDLPOne); } @Scheduled(fixedDelay = 1000) public void outBigStorageTask() throws Exception { Date startDate = new Date(); S7DataDLPTwo s7DataWLTwo = s7SerializerDLPTwo.read(S7DataDLPTwo.class); // ReadWriteEntity inkageEntity = miloService.readFromOpcUa("DLP1B.DLP1B.mesControl"); // if (true != Boolean.parseBoolean(inkageEntity.getValue() + "")) { Boolean inkageEntity = s7DataWLTwo.getMesControl(); if (true != inkageEntity) { log.info("当前为非联机状态，结束进片任务"); return; } // ReadWriteEntity requestEntity = miloService.readFromOpcUa("DLP1B.DLP1B.RequestMes"); // if (!"1".equals(requestEntity.getValue() + "")) { String requestEntity = s7DataWLTwo.getRequestMes().toString(); if (!"1".equals(requestEntity)) { log.info("当前未收到出片请求，结束出片任务"); return; } //获取出片任务表 List outTaskList = getOutTaskList(s7DataWLTwo); // List outTaskList = bigStorageCageTaskService.queryTaskMessage("big_storage_cage_out_one_task"); if (CollectionUtil.isNotEmpty(outTaskList)) { log.info("有正在执行的出片任务，结束本次出片任务"); return; } //是否允许钢化 //是否有正在钢化的玻璃:钢化小片表关联历史任务表，筛选未出笼的玻璃信息 // 获取当前钢化任务未完成出片的玻璃信息 Integer temperingOutTargetPosition = sysConfigService.queryConfigValue(ConstSysConfig.VERTICAL_TEMPERING_OUT_TARGET_POSITION); List unFinishTemperingGlassInfoList = temperingGlassInfoService.list(new LambdaQueryWrapper() .eq(TemperingGlassInfo::getState, Const.TEMPERING_NEW).orderByAsc(TemperingGlassInfo::getTemperingLayoutId).orderByAsc(TemperingGlassInfo::getTemperingFeedSequence)); if (CollectionUtil.isNotEmpty(unFinishTemperingGlassInfoList)) { log.info("有正在出片的钢化任务"); computeOutGlassInfoByVirtualSlot(unFinishTemperingGlassInfoList, "big_storage_cage_out_one_task", temperingOutTargetPosition, Const.GLASS_STATE_OUT_ING, Const.BIG_STORAGE_BEFORE_OUT); Date endDate = new Date(); log.info("大理片笼出片任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime()); return; } BigStorageCageDetails details = bigStorageCageDetailsService.getOne(new LambdaQueryWrapper() .eq(BigStorageCageDetails::getSlot, THROUGH_SLOT) .in(BigStorageCageDetails::getState, Const.GLASS_STATE_IN_ALL).last("limit 1")); if (details != null) { TemperingGlassInfo temperingGlassInfo = new TemperingGlassInfo(); BeanUtils.copyProperties(details, temperingGlassInfo); temperingGlassInfo.setState(-1); temperingGlassInfoService.save(temperingGlassInfo); computeOutGlassInfoByVirtualSlot(Arrays.asList(temperingGlassInfo), "big_storage_cage_out_one_task", temperingOutTargetPosition, Const.GLASS_STATE_OUT_ING, Const.BIG_STORAGE_BEFORE_OUT); return; } if (redisUtil.getCacheObject("temperingSwitch")) { //钢化优先：获取理片笼 玻璃小片 破损表 数量 判断笼内版图是否到齐 List temperingLayoutDTOList = bigStorageCageDetailsService.temperingIsAll(); if (CollectionUtil.isNotEmpty(temperingLayoutDTOList)) { //玻璃到齐包括已出片的 //到齐，将玻璃小片数据存入钢化小片表，逻辑生成出片任务 结束 for (TemperingLayoutDTO item : temperingLayoutDTOList) { // if (item.getEngineerId().equals(redisUtil.getCacheObject("temperingengineerId"))) { List temperingGlassInfos = glassInfoService.selectJoinList(TemperingGlassInfo.class, JoinWrappers.lambda(GlassInfo.class) .select("-1 as state,t.filmsid as films_id,t.glass_id,t.flow_card_id,t.glass_type,t.width,t.height" + ",t.thickness,t.ishorizontal,t.tempering_layout_id,t.tempering_feed_sequence,t.x_coordinate,t.y_coordinate," + "t.angle,t1.slot,t.engineer_id") .innerJoin(BigStorageCageDetails.class, BigStorageCageDetails::getGlassId, GlassInfo::getGlassId) .eq(BigStorageCageDetails::getState, Const.GLASS_STATE_IN) .eq(GlassInfo::getTemperingLayoutId, item.getTemperingLayoutId()) .eq(GlassInfo::getEngineerId, item.getEngineerId()) .orderByAsc(GlassInfo::getTemperingFeedSequence)); if (CollectionUtil.isNotEmpty(temperingGlassInfos)) { temperingGlassInfoService.saveBatch(temperingGlassInfos); computeOutGlassInfoByVirtualSlot(temperingGlassInfos, "big_storage_cage_out_one_task", temperingOutTargetPosition, Const.GLASS_STATE_OUT_ING, Const.BIG_STORAGE_BEFORE_OUT); Date endDate = new Date(); log.info("大理片笼出片任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime()); return; } // } } } } //是否有人工下片任务 有直接出 Integer artificialOutTargetPosition = sysConfigService.queryConfigValue(ConstSysConfig.VERTICAL_ARTIFICIAL_OUT_TARGET_POSITION); Integer outCarMaxSize = sysConfigService.queryConfigValue(ConstSysConfig.VERTICAL_OUT_CAR_SIZE); List artificialList = bigStorageCageDetailsService.list(new LambdaQueryWrapper() .eq(BigStorageCageDetails::getState, Const.GLASS_STATE_ARTIFICIAL) .orderByAsc(BigStorageCageDetails::getSlot) .orderByAsc(BigStorageCageDetails::getId).last("limit " + outCarMaxSize)); if (CollectionUtil.isNotEmpty(artificialList)) { computeOutGlassInfoByVirtualSlot(artificialList, "big_storage_cage_out_one_task", artificialOutTargetPosition, Const.GLASS_STATE_OUT_ING, Const.BIG_STORAGE_BEFORE_OUT); Date endDate = new Date(); log.info("大理片笼出片任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime()); return; } //是否存在需要内部调度的格子:执行内部调度任务 if (redisUtil.getCacheObject("dispatchSwitch")) { //todo:获取笼内单格已经到齐的玻璃格子信息 List virtualList = bigStorageCageDetailsService.queryIsAllNeedDispatchVirtualSlot(); if (CollectionUtil.isEmpty(virtualList)) { log.info("没有需要调度的格子"); return; } List list = new ArrayList<>(); loop: for (BigStorageRelationDTO dto : virtualList) { List sequenceDTOList = bigStorageCageDetailsService.dispatchBigStorageGlassInfo(dto); if (CollectionUtil.isEmpty(sequenceDTOList) || sequenceDTOList.size() == 1) { continue; } int sequence = -1; int targetSlot = -1; for (BigStorageSequenceDTO item : sequenceDTOList) { if (item.getMaxSequence() == sequence - 1) { //生成调度任务 int startSlot = item.getSlot(); list = bigStorageCageDetailsService.list(new LambdaQueryWrapper() .eq(BigStorageCageDetails::getState, Const.GLASS_STATE_IN).eq(BigStorageCageDetails::getSlot, startSlot)); computeOutGlassInfoByVirtualSlot(list, "big_storage_cage_out_one_task", targetSlot, Const.GLASS_STATE_SCHEDULE_ING, Const.BIG_STORAGE_BEFORE_DISPATCH); List slotList = new ArrayList<>(); slotList.add(targetSlot); updateSlotRemainBySlots(slotList); break loop; } sequence = item.getMinSequence(); targetSlot = item.getSlot(); } } } Date endDate = new Date(); log.info("大理片笼出片任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime()); return; } @Scheduled(fixedDelay = 1000) public void finishInBigStorageTask() throws Exception { S7DataDLPOne s7DataDLPOne = s7SerializerDLPOne.read(S7DataDLPOne.class); // ReadWriteEntity inkageEntity = miloService.readFromOpcUa("DLP1A.DLP1A.mesControl"); // if (true != Boolean.parseBoolean(inkageEntity.getValue() + "")) { Boolean inkageEntity = s7DataDLPOne.getMesControl(); if (true != inkageEntity) { log.info("当前为非联机状态，结束完成进片任务"); return; } //获取进片任务表 // List inTaskList = bigStorageCageTaskService.queryTaskMessage("big_storage_cage_in_one_task"); List inTaskList = new ArrayList(); List glassIdList = new ArrayList<>(); // ReadWriteEntity toWord = miloService.readFromOpcUa("DLP1A.DLP1A.TO1"); // if ("0".equals(toWord.getValue() + "")) { String toWord = s7DataDLPOne.getTo1().toString(); if ("0".equals(toWord)) { log.info("完成任务已执行，结束本次完成进片任务"); return; } for (int i = 0; i < 6; i++) { // ReadWriteEntity requestWord = miloService.readFromOpcUa("DLP1A.DLP1A.DI" + i); // ReadWriteEntity statetWord = miloService.readFromOpcUa("DLP1A.DLP1A.STATE" + i); // ReadWriteEntity toOpcUa = miloService.readFromOpcUa("DLP1A.DLP1A.TO" + i); // ReadWriteEntity fromOpcUa = miloService.readFromOpcUa("DLP1A.DLP1A.FROM" + i); String requestWord = ""; String statetWord = ""; String toOpcUa = ""; String fromOpcUa = ""; switch (i) { case 0: requestWord = s7DataDLPOne.getId1(); statetWord = s7DataDLPOne.getState1().toString(); toOpcUa = s7DataDLPOne.getTo1().toString(); fromOpcUa = s7DataDLPOne.getFrom1().toString(); break; case 1: requestWord = s7DataDLPOne.getId2(); statetWord = s7DataDLPOne.getState2().toString(); toOpcUa = s7DataDLPOne.getTo2().toString(); fromOpcUa = s7DataDLPOne.getFrom2().toString(); break; case 2: requestWord = s7DataDLPOne.getId3(); statetWord = s7DataDLPOne.getState3().toString(); toOpcUa = s7DataDLPOne.getTo3().toString(); fromOpcUa = s7DataDLPOne.getFrom3().toString(); break; case 3: requestWord = s7DataDLPOne.getId4(); statetWord = s7DataDLPOne.getState4().toString(); toOpcUa = s7DataDLPOne.getTo4().toString(); fromOpcUa = s7DataDLPOne.getFrom4().toString(); break; case 4: requestWord = s7DataDLPOne.getId5(); statetWord = s7DataDLPOne.getState5().toString(); toOpcUa = s7DataDLPOne.getTo5().toString(); fromOpcUa = s7DataDLPOne.getFrom5().toString(); break; case 5: requestWord = s7DataDLPOne.getId6(); statetWord = s7DataDLPOne.getState6().toString(); toOpcUa = s7DataDLPOne.getTo6().toString(); fromOpcUa = s7DataDLPOne.getFrom6().toString(); break; } // if (null != requestWord.getValue()) { if (!requestWord.isEmpty()) { BigStorageCageTask task = new BigStorageCageTask(); // task.setGlassId(requestWord.getValue() + ""); // task.setTargetSlot(Integer.parseInt(toOpcUa.getValue() + "")); // task.setTaskState(Integer.parseInt(statetWord.getValue() + "")); // task.setStartSlot(Integer.parseInt(fromOpcUa.getValue() + "")); task.setGlassId(requestWord); task.setTargetSlot(Integer.parseInt(toOpcUa)); task.setTaskState(Integer.parseInt(statetWord)); task.setStartSlot(Integer.parseInt(fromOpcUa)); inTaskList.add(task); // glassIdList.add(requestWord.getValue() + ""); glassIdList.add(requestWord); continue; } } if (CollectionUtil.isEmpty(inTaskList)) { log.info("当前大车无进片玻璃，结束完成进片任务"); return; } List unFinishTaskList = inTaskList.stream().filter(e -> e.getTaskState() <= 1 || e.getStartSlot() == 0).collect(Collectors.toList()); if (CollectionUtil.isNotEmpty(unFinishTaskList)) { log.info("存在未完成的玻璃信息,玻璃：{}", unFinishTaskList); return; } Map> taskMap = inTaskList.stream().collect(Collectors.groupingBy(BigStorageCageTask::getTaskState)); //按照任务状态修改大理片笼内的玻璃数据 // 重新计算大理片笼内的剩余尺寸 taskMap.forEach((e1, v) -> { if (e1 == 2) { //进片完成 log.info("3、获取进片已完成的玻璃信息id:{}", v); List inSuccessGlassSlot = v.stream().map(BigStorageCageTask::getTargetSlot).collect(Collectors.toList()); List storageCageDTOList = v.stream().map(e -> { UpdateBigStorageCageDTO storageCageDTO = new UpdateBigStorageCageDTO(); BeanUtils.copyProperties(e, storageCageDTO); return storageCageDTO; }).collect(Collectors.toList()); bigStorageCageDetailsService.updateBySlot(storageCageDTOList, Const.GLASS_STATE_IN); log.info("4、大理片笼进片状态已完成已完成的玻璃信息id:{}", v); updateSlotRemainBySlots(inSuccessGlassSlot); } else if (e1 == 3) { //破损处理 dealDamageInTask(v); } else { //清空理片笼空数据 noDealInTask(v); } }); for (BigStorageCageTask item : inTaskList) { //更新历史任务表中的任务状态 bigStorageCageHistoryTaskService.update(new LambdaUpdateWrapper() .set(BigStorageCageHistoryTask::getTaskState, item.getTaskState()) .eq(BigStorageCageHistoryTask::getTaskType, Const.BIG_STORAGE_BEFORE_IN) .eq(BigStorageCageHistoryTask::getTargetSlot, item.getTargetSlot()) .eq(BigStorageCageHistoryTask::getGlassId, item.getGlassId())); item.setTargetSlot(0); //清空任务表数据 // bigStorageCageTaskService.updateTaskMessage("big_storage_cage_in_one_task", item); } //清空启动状态 //向opc发送启动信号 //向opc发送启动信号 // List list = new ArrayList<>(); // for (int i = 1; i <= 6; i++) { // list.add(generateReadWriteEntity("DLP1A.DLP1A.TO" + i, 0)); // } // list.add(generateReadWriteEntity("DLP1A.DLP1A.MesReply", 0)); // miloService.writeToOpcWord(list); s7DataDLPOne = new S7DataDLPOne(); s7DataDLPOne.setTo1(0); s7DataDLPOne.setTo2(0); s7DataDLPOne.setTo3(0); s7DataDLPOne.setTo4(0); s7DataDLPOne.setTo5(0); s7DataDLPOne.setTo6(0); s7DataDLPOne.setMesReply(0); s7SerializerDLPOne.write(s7DataDLPOne); } @Scheduled(fixedDelay = 1000) public void finishOutBigStorageTask() throws Exception { S7DataDLPTwo s7DataWLTwo = s7SerializerDLPTwo.read(S7DataDLPTwo.class); // ReadWriteEntity inkageEntity = miloService.readFromOpcUa("DLP1B.DLP1B.mesControl"); // if (true != Boolean.parseBoolean(inkageEntity.getValue() + "")) { Boolean inkageEntity = s7DataWLTwo.getMesControl(); if (true != inkageEntity) { log.info("当前为非联机状态，结束完成出片任务"); return; } //获取出片任务表 List outTaskList = getOutTaskList(s7DataWLTwo); // List outTaskList = bigStorageCageTaskService.queryTaskMessage("big_storage_cage_out_one_task"); if (CollectionUtil.isEmpty(outTaskList)) { log.info("当前大车无出片玻璃，结束完成出片任务"); return; } List unFinishTaskList = outTaskList.stream().filter(e -> e.getTaskState() <= 1 || e.getStartSlot() == 0).collect(Collectors.toList()); if (CollectionUtil.isNotEmpty(unFinishTaskList)) { log.info("存在未完成的玻璃信息,玻璃：{}", unFinishTaskList); return; } Map> taskMap = outTaskList.stream().collect(Collectors.groupingBy(BigStorageCageTask::getTaskState)); int taskType = 0; if (Const.OUT_TARGET_POSITION_ALL.contains(outTaskList.get(0).getTargetSlot())) { taskType = Const.BIG_STORAGE_BEFORE_OUT; } else { taskType = Const.BIG_STORAGE_BEFORE_DISPATCH; } //按照任务状态修改大理片笼内的玻璃数据 // 重新计算大理片笼内的剩余尺寸 Integer finalTaskType = taskType; taskMap.forEach((e1, v) -> { if (e1 == 2) { //进片完成 log.info("3、获取进片已完成的玻璃信息id:{}", v); List outSuccessGlassSlot = new ArrayList<>(); if (finalTaskType.equals(Const.BIG_STORAGE_BEFORE_OUT)) { outSuccessGlassSlot = v.stream().map(BigStorageCageTask::getStartSlot).collect(Collectors.toList()); } else { List targetSuccessGlassSlot = v.stream().map(BigStorageCageTask::getTargetSlot).collect(Collectors.toList()); List startoutSuccessGlassSlot = v.stream().map(BigStorageCageTask::getStartSlot).collect(Collectors.toList()); outSuccessGlassSlot.addAll(targetSuccessGlassSlot); outSuccessGlassSlot.addAll(startoutSuccessGlassSlot); } List storageCageDTOList = v.stream().map(e -> { UpdateBigStorageCageDTO storageCageDTO = new UpdateBigStorageCageDTO(); storageCageDTO.setGlassId(e.getGlassId()); if (finalTaskType.equals(Const.BIG_STORAGE_BEFORE_OUT)) { storageCageDTO.setTargetSlot(e.getStartSlot()); } else { storageCageDTO.setTargetSlot(e.getTargetSlot()); } return storageCageDTO; }).collect(Collectors.toList()); if (finalTaskType.equals(Const.BIG_STORAGE_BEFORE_OUT)) { bigStorageCageDetailsService.updateBySlot(storageCageDTOList, Const.GLASS_STATE_OUT); } else { bigStorageCageDetailsService.updateBySlot(storageCageDTOList, Const.GLASS_STATE_IN); //按照格子信息更新对应的设备id List slotList = storageCageDTOList.stream().map(UpdateBigStorageCageDTO::getTargetSlot).distinct().collect(Collectors.toList()); bigStorageCageDetailsService.updateDeviceIdBySlot(slotList); } log.info("4、大理片笼进片状态已完成已完成的玻璃信息id:{}", v); updateSlotRemainBySlots(outSuccessGlassSlot); } else if (e1 == 3) { //破损处理 dealDamageOutTask(v); } else { //清空理片笼空数据 noDealOutTask(v); } }); for (BigStorageCageTask item : outTaskList) { //更新历史任务表中的任务状态 bigStorageCageHistoryTaskService.update(new LambdaUpdateWrapper() .set(BigStorageCageHistoryTask::getTaskState, item.getTaskState()) .eq(BigStorageCageHistoryTask::getTaskType, taskType) .eq(BigStorageCageHistoryTask::getGlassId, item.getGlassId())); //更新钢化小片表 Integer taskState = item.getTaskState(); if (taskState == 2) { temperingGlassInfoService.update(new LambdaUpdateWrapper() .set(TemperingGlassInfo::getState, Const.TEMPERING_OUT).eq(TemperingGlassInfo::getGlassId, item.getGlassId())); } else if (taskState == 3) { // temperingGlassInfoService.remove(new LambdaQueryWrapper().eq(TemperingGlassInfo::getGlassId, item.getGlassId())); temperingGlassInfoService.update(new LambdaUpdateWrapper() .set(TemperingGlassInfo::getState, Const.TEMPERING_DAMAGE ).eq(TemperingGlassInfo::getGlassId, item.getGlassId())); } else { // 空执行 } } // 重置任务表数据 // bigStorageCageTaskService.updateOutTaskMessage("big_storage_cage_out_one_task"); resetOutTask(); //清空启动状态 //向opc发送启动信号 // miloService.writeToOpcWord(generateReadWriteEntity("DLP1B.DLP1B.MesReply", 0)); S7DataDLPTwo s7DataDLPTwo = new S7DataDLPTwo(); s7DataDLPTwo.setMesReply(0); s7SerializerDLPTwo.write(s7DataDLPTwo); } private void dealDamageInTask(List damageTaskList) { // 获取进片任务表中状态为破损的数据 log.info("破损的玻璃信息有：{}", damageTaskList); //移除理片笼详情表任务执行过程中破损的玻璃 bigStorageCageDetailsService.remove(new LambdaQueryWrapper() .eq(BigStorageCageDetails::getState, Const.GLASS_STATE_NEW) .in(BigStorageCageDetails::getGlassId, damageTaskList.stream().map(BigStorageCageTask::getGlassId).collect(Collectors.toList()))); //将破损信息新增入破损表 List slotList = new ArrayList<>(); for (BigStorageCageTask item : damageTaskList) { Damage damage = new Damage(); damage.setGlassId(item.getGlassId()); damage.setLine(item.getStartSlot()); damage.setWorkingProcedure("大理片笼"); damage.setRemark("进笼前卧转立"); damage.setStatus(1); damage.setType(item.getTaskState()); damageService.insertDamage(damage); slotList.add(item.getTargetSlot()); } //更新格子剩余宽度 updateSlotRemainBySlots(slotList); log.info("进片任务-破损任务执行完成"); } private void dealDamageOutTask(List damageTaskList) { // 获取进片任务表中状态为破损的数据 log.info("破损的玻璃信息有：{}", damageTaskList); //移除理片笼详情表任务执行过程中破损的玻璃 bigStorageCageDetailsService.remove(new LambdaQueryWrapper() .in(BigStorageCageDetails::getState, Const.GLASS_STATE_IN_ALL_ZERO) .in(BigStorageCageDetails::getGlassId, damageTaskList.stream().map(BigStorageCageTask::getGlassId).collect(Collectors.toList()))); //将破损信息新增入破损表 List slotList = new ArrayList<>(); for (BigStorageCageTask item : damageTaskList) { Damage damage = new Damage(); damage.setGlassId(item.getGlassId()); damage.setLine(item.getStartSlot()); damage.setWorkingProcedure("钢化前"); damage.setRemark("进笼后卧转立"); damage.setStatus(1); damage.setType(item.getTaskState()); damageService.insertDamage(damage); slotList.add(item.getTargetSlot()); slotList.add(item.getStartSlot()); } //更新格子剩余宽度 updateSlotRemainBySlots(slotList); log.info("出片任务-破损任务执行完成"); } private void noDealInTask(List noDealTaskList) { // 获取进片任务表中状态为破损的数据 log.info("破损的玻璃信息有：{}", noDealTaskList); //移除理片笼详情表未执行任务的空记录信息 bigStorageCageDetailsService.remove(new LambdaQueryWrapper() .eq(BigStorageCageDetails::getState, Const.GLASS_STATE_NEW) .in(BigStorageCageDetails::getGlassId, noDealTaskList.stream().map(BigStorageCageTask::getGlassId).collect(Collectors.toList()))); //记录格子号，按格子号更新剩余尺寸 List slotList = new ArrayList<>(); for (BigStorageCageTask item : noDealTaskList) { slotList.add(item.getTargetSlot()); slotList.add(item.getStartSlot()); } //更新格子剩余宽度 updateSlotRemainBySlots(slotList); log.info("进片任务-无动作执行完成"); } private void noDealOutTask(List noDealTaskList) { // 获取进片任务表中状态为破损的数据 log.info("破损的玻璃信息有：{}", noDealTaskList); if (Const.OUT_TARGET_POSITION_ALL.contains(noDealTaskList.get(0).getTargetSlot())) { //出片任务:将出片中状态恢复为在笼内 List glassList = noDealTaskList.stream().map(BigStorageCageTask::getGlassId).collect(Collectors.toList()); bigStorageCageDetailsService.update(new LambdaUpdateWrapper() .set(BigStorageCageDetails::getState, Const.GLASS_STATE_IN) .ne(BigStorageCageDetails::getState, Const.GLASS_STATE_OUT) .in(BigStorageCageDetails::getGlassId, glassList)); } else { //调度任务：将调度中状态改为在笼内，格子号恢复为调度前的格子 for (BigStorageCageTask item : noDealTaskList) { bigStorageCageDetailsService.update(new LambdaUpdateWrapper() .set(BigStorageCageDetails::getSlot, item.getStartSlot()) .set(BigStorageCageDetails::getState, Const.GLASS_STATE_IN) .ne(BigStorageCageDetails::getState, Const.GLASS_STATE_OUT) .eq(BigStorageCageDetails::getGlassId, item.getGlassId())); } } //将破损信息新增入破损表 List slotList = new ArrayList<>(); for (BigStorageCageTask item : noDealTaskList) { slotList.add(item.getTargetSlot()); slotList.add(item.getStartSlot()); } //更新格子剩余宽度 updateSlotRemainBySlots(slotList); log.info("出片任务-无动作执行完成"); } /** * 出片一次仅生成一车玻璃 * * @param list * @param * @return */ private Boolean computeOutGlassInfoByVirtualSlot(List list, String tableName, int targetSlot, int state, int taskType) { //任务数据:获取车子存放玻璃最大数量,玻璃间隔 List outGlassList = list; if (!THROUGH_SLOT.equals(list.get(0).getSlot())) { //todo:临时解决方案:出片时考虑玻璃碰撞，改为一片一出 // 界面关闭调度开关 !Const.BIG_STORAGE_BEFORE_DISPATCH.equals(taskType) if (list.get(0).getThickness() >= 8) { outGlassList = list.subList(0, 1); } else { List glassIdList = bigStorageGlassRelationInfoService.queryNeedOutGlassId( list.get(0).getEngineerId(), list.get(0).getTemperingLayoutId(), list.get(0).getTemperingFeedSequence()); outGlassList = list.stream().filter(e -> glassIdList.contains(e.getGlassId())).collect(Collectors.toList()); } } Assert.isFalse(CollectionUtil.isEmpty(outGlassList), "未获取出片数据，结束出片任务"); log.info("获取出片任务数据{}条，执行保存", outGlassList.size()); List bigStorageCageTaskList = outGlassList.stream() .map(e -> new BigStorageCageTask(e.getGlassId(), e.getSlot(), targetSlot, 0)).collect(Collectors.toList()); List glassIds = bigStorageCageTaskList.stream().map(BigStorageCageTask::getGlassId).collect(Collectors.toList()); int glassCount = bigStorageCageTaskList.size(); //生成出片任务条数不足6补全 // while (bigStorageCageTaskList.size() < 6) { // bigStorageCageTaskList.add(new BigStorageCageTask("", 0, 0, 0)); // } //清空任务表数据 resetOutTask(); S7DataDLPTwo s7DataDLPTwo = new S7DataDLPTwo(); for (int i = 0; i < bigStorageCageTaskList.size() && i < 6; i++) { String glassId = bigStorageCageTaskList.get(i).getGlassId(); Integer startSlot = bigStorageCageTaskList.get(i).getStartSlot(); Integer target = bigStorageCageTaskList.get(i).getTargetSlot(); if (startSlot > 0) { switch (i) { case 0: s7DataDLPTwo.setId1(glassId); s7DataDLPTwo.setFrom1(startSlot); s7DataDLPTwo.setTo1(target); break; case 1: s7DataDLPTwo.setId2(glassId); s7DataDLPTwo.setFrom2(startSlot); s7DataDLPTwo.setTo2(target); break; case 2: s7DataDLPTwo.setId3(glassId); s7DataDLPTwo.setFrom3(startSlot); s7DataDLPTwo.setTo3(target); break; case 3: s7DataDLPTwo.setId4(glassId); s7DataDLPTwo.setFrom4(startSlot); s7DataDLPTwo.setTo4(target); break; case 4: s7DataDLPTwo.setId5(glassId); s7DataDLPTwo.setFrom5(startSlot); s7DataDLPTwo.setTo5(target); break; case 5: s7DataDLPTwo.setId6(glassId); s7DataDLPTwo.setFrom6(startSlot); s7DataDLPTwo.setTo6(target); break; } } } s7SerializerDLPTwo.write(s7DataDLPTwo); // bigStorageCageTaskService.removeAll("big_storage_cage_out_one_task"); // bigStorageCageTaskService.saveTaskMessage(tableName, bigStorageCageTaskList); List historyList = bigStorageCageTaskList.stream().filter(e -> StringUtils.isNotBlank(e.getGlassId())).map(e -> { BigStorageCageHistoryTask history = new BigStorageCageHistoryTask(); BeanUtils.copyProperties(e, history); history.setGlassCount(glassCount); history.setTaskType(taskType); return history; }).collect(Collectors.toList()); bigStorageCageHistoryTaskService.saveBatch(historyList); log.info("将出片玻璃{}玻璃状态改为出片中", glassIds); bigStorageCageDetailsService.update(new LambdaUpdateWrapper() .set(BigStorageCageDetails::getState, state) .set(Const.BIG_STORAGE_BEFORE_DISPATCH.equals(taskType), BigStorageCageBaseInfo::getSlot, targetSlot) .ne(BigStorageCageDetails::getState, Const.GLASS_STATE_OUT) .in(BigStorageCageDetails::getGlassId, glassIds)); try { // miloService.writeToOpcWord(generateReadWriteEntity("DLP1B.DLP1B.MesReply", 1)); s7DataDLPTwo = new S7DataDLPTwo(); s7DataDLPTwo.setMesReply(1); s7SerializerDLPTwo.write(s7DataDLPTwo); } catch (Exception e) { e.printStackTrace(); } return Boolean.TRUE; } // /** // * 出片一次仅生成一车玻璃 // * // * @param list // * @param // * @return // */ private Boolean computeOutGlassInfo(List list, String tableName, int targetSlot, int state, int taskType) { //任务数据:获取车子存放玻璃最大数量,玻璃间隔 List bigStorageCageTaskList = new ArrayList<>(); //打车剩余尺寸 Integer outCarMaxSize = sysConfigService.queryConfigValue(ConstSysConfig.VERTICAL_OUT_CAR_SIZE); Integer glassGap = sysConfigService.queryConfigValue(ConstSysConfig.VERTICAL_GLASS_GAP); Integer remainWidth = sysConfigService.queryConfigValue(ConstSysConfig.VERTICAL_CAR_WIDTH); for (T e : list) { if (bigStorageCageTaskList.size() >= outCarMaxSize || Math.max((int) e.getWidth(), (int) e.getHeight()) > remainWidth) { break; } //计算当前出片车剩尺寸 remainWidth = remainWidth - Math.max((int) e.getWidth(), (int) e.getHeight()) - glassGap; bigStorageCageTaskList.add(new BigStorageCageTask(e.getGlassId(), e.getSlot(), targetSlot, 0)); } Assert.isFalse(CollectionUtil.isEmpty(bigStorageCageTaskList), "未获取出片数据，结束出片任务"); log.info("获取出片任务数据{}条，执行保存", bigStorageCageTaskList.size()); List glassIds = bigStorageCageTaskList.stream().map(BigStorageCageTask::getGlassId).collect(Collectors.toList()); int glassCount = bigStorageCageTaskList.size(); //生成出片任务条数不足6补全 while (bigStorageCageTaskList.size() < 6) { bigStorageCageTaskList.add(new BigStorageCageTask("", 0, 0, 0)); } //清空任务表数据 bigStorageCageTaskService.removeAll("big_storage_cage_out_one_task"); bigStorageCageTaskService.saveTaskMessage(tableName, bigStorageCageTaskList); List historyList = bigStorageCageTaskList.stream().filter(e -> StringUtils.isNotBlank(e.getGlassId())).map(e -> { BigStorageCageHistoryTask history = new BigStorageCageHistoryTask(); BeanUtils.copyProperties(e, history); history.setGlassCount(glassCount); history.setTaskType(taskType); return history; }).collect(Collectors.toList()); bigStorageCageHistoryTaskService.saveBatch(historyList); log.info("将出片玻璃{}玻璃状态改为出片中", glassIds); bigStorageCageDetailsService.update(new LambdaUpdateWrapper() .set(BigStorageCageDetails::getState, state) .ne(BigStorageCageDetails::getState, Const.GLASS_STATE_OUT) .set(Const.GLASS_STATE_SCHEDULE_ING.equals(state), BigStorageCageBaseInfo::getSlot, targetSlot) .in(BigStorageCageDetails::getGlassId, glassIds)); try { // miloService.writeToOpcWord(generateReadWriteEntity("DLP1B.DLP1B.MesReply", 1)); S7DataDLPTwo s7DataDLPTwo = new S7DataDLPTwo(); s7DataDLPTwo.setMesReply(1); s7SerializerDLPTwo.write(s7DataDLPTwo); } catch (Exception e) { e.printStackTrace(); } return Boolean.TRUE; } public void updateSlotRemainBySlots(List slotList) { //获取格子内所有的玻璃信息 List inSlotGlassList = bigStorageCageDetailsService.list(new LambdaQueryWrapper() .in(BigStorageCageDetails::getSlot, slotList).in(BigStorageCageDetails::getState, Const.GLASS_STATE_IN_ALL)); Map slotRemainMap = new HashMap<>(); Integer glassGap = sysConfigService.queryConfigValue(ConstSysConfig.VERTICAL_GLASS_GAP); Integer slotWidth = sysConfigService.queryConfigValue(ConstSysConfig.VERTICAL_SLOT_WIDTH); //是否存在有格子非空的玻璃 if (CollectionUtil.isNotEmpty(inSlotGlassList)) { //存在 将格子内的玻璃分别进行更新 slotRemainMap = inSlotGlassList.stream() .collect(Collectors.groupingBy(BigStorageCageDetails::getSlot, Collectors.summingDouble(item -> Math.max(item.getWidth(), item.getHeight()) + glassGap))); slotRemainMap.forEach((e, v) -> { double remainWidth = slotWidth - v >= 0 ? slotWidth - v : 0; bigStorageCageService.update(new LambdaUpdateWrapper().set(BigStorageCage::getRemainWidth, remainWidth) .eq(BigStorageCage::getSlot, e)); }); } //过滤不存在玻璃的格子 将宽度重置为原始宽度5000 Set remainSlotList = slotRemainMap.keySet(); slotList.removeAll(remainSlotList); if (CollectionUtil.isNotEmpty(slotList)) { bigStorageCageService.update(new LambdaUpdateWrapper().set(BigStorageCage::getRemainWidth, slotWidth) .in(BigStorageCage::getSlot, slotList)); } } private ReadWriteEntity generateReadWriteEntity(String identifier, Object value) { return ReadWriteEntity.builder() .identifier(identifier) //Kep中是Long类型，即：Int32，Java中的int类型 .value(value) .build(); } //重置任务表 private void resetOutTask() { S7DataDLPTwo s7DataDLPTwo = new S7DataDLPTwo(); s7DataDLPTwo.setId1(""); s7DataDLPTwo.setId2(""); s7DataDLPTwo.setId3(""); s7DataDLPTwo.setId4(""); s7DataDLPTwo.setId5(""); s7DataDLPTwo.setId6(""); s7DataDLPTwo.setFrom1(0); s7DataDLPTwo.setFrom2(0); s7DataDLPTwo.setFrom3(0); s7DataDLPTwo.setFrom4(0); s7DataDLPTwo.setFrom5(0); s7DataDLPTwo.setFrom6(0); s7DataDLPTwo.setTo1(0); s7DataDLPTwo.setTo2(0); s7DataDLPTwo.setTo3(0); s7DataDLPTwo.setTo4(0); s7DataDLPTwo.setTo5(0); s7DataDLPTwo.setTo6(0); s7DataDLPTwo.setState1(0); s7DataDLPTwo.setState2(0); s7DataDLPTwo.setState3(0); s7DataDLPTwo.setState4(0); s7DataDLPTwo.setState5(0); s7DataDLPTwo.setState6(0); s7SerializerDLPTwo.write(s7DataDLPTwo); } //读取出片地址 private List getOutTaskList(S7DataDLPTwo s7DataDLPTwo) { List outTaskList = new ArrayList<>(); List glassIds = s7DataDLPTwo.getIds(); List startSlots = s7DataDLPTwo.getFroms(); List endSlots = s7DataDLPTwo.getTos(); List states = s7DataDLPTwo.getStates(); for (int i = 0; i < 6; i++) { if (glassIds.get(i) != null && !glassIds.get(i).isEmpty()) { BigStorageCageTask bigStorageCageTask = new BigStorageCageTask(); bigStorageCageTask.setGlassId(glassIds.get(i)); bigStorageCageTask.setStartSlot(startSlots.get(i)); bigStorageCageTask.setTargetSlot(endSlots.get(i)); bigStorageCageTask.setTaskState(states.get(i)); outTaskList.add(bigStorageCageTask); } } return outTaskList; } }