package com.mes.job; import cn.hutool.core.lang.Assert; import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper; import com.baomidou.mybatisplus.core.toolkit.CollectionUtils; import com.github.yulichang.toolkit.JoinWrappers; import com.github.yulichang.wrapper.MPJLambdaWrapper; import com.mes.base.entity.BigStorageCageBaseInfo; import com.mes.bigstorage.entity.BigStorageCage; import com.mes.bigstorage.entity.BigStorageCageDetails; import com.mes.bigstorage.entity.BigStorageDTO; import com.mes.bigstorage.entity.dto.SlotSequenceDTO; import com.mes.bigstorage.entity.dto.TemperingLayoutDTO; import com.mes.bigstorage.service.BigStorageCageDetailsService; import com.mes.bigstorage.service.BigStorageCageService; import com.mes.bigstoragetask.entity.BigStorageCageFeedTask; import com.mes.bigstoragetask.entity.BigStorageCageOutTask; import com.mes.bigstoragetask.entity.UpdateBigStorageCageDTO; import com.mes.bigstoragetask.service.BigStorageCageFeedTaskService; import com.mes.bigstoragetask.service.BigStorageCageOutTaskService; import com.mes.common.S7object; import com.mes.common.config.Const; import com.mes.common.utils.RedisUtil; import com.mes.damage.entity.Damage; import com.mes.damage.service.DamageService; import com.mes.device.PlcParameterObject; 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.temperingglass.entity.TemperingGlassInfo; import com.mes.temperingglass.service.TemperingGlassInfoService; 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.Value; 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 PlcStorageCageTask { @Resource private BigStorageCageService bigStorageCageService; @Resource private BigStorageCageDetailsService bigStorageCageDetailsService; @Resource private GlassInfoService glassInfoService; @Resource private BigStorageCageFeedTaskService bigStorageCageFeedTaskService; @Resource private BigStorageCageOutTaskService bigStorageCageOutTaskService; @Resource private EdgGlassTaskInfoService edgGlassTaskInfoService; @Resource private TemperingGlassInfoService temperingGlassInfoService; @Resource private DamageService damageService; @Resource private RedisUtil redisUtil; private static final String REQUEST_WORD = "1"; @Value("${mes.sequence.order}") private boolean sequenceOrder; @Value("${mes.carWidth}") private Integer carWidth; @Value("${mes.slotWidth}") private Integer slotWidth; @Value("${mes.inCarMaxSize}") private Integer inCarMaxSize; @Value("${mes.outCarMaxSize}") private Integer outCarMaxSize; @Value("${mes.glassGap}") private Integer glassGap; @Value("${mes.xMaxSize}") private Integer xMaxSize; private String d01GlassId = ""; private String d04GlassId = ""; @Scheduled(fixedDelay = 300) public void plcToHomeEdgScan() { Date startDate = new Date(); log.info("大理片笼扫码任务开始执行时间：{}", startDate); PlcParameterObject plcParameterObject = S7object.getinstance().PlcMesObject; String d01Id = plcParameterObject.getPlcParameter("D01ID").getValue(); String d04Id = plcParameterObject.getPlcParameter("D04ID").getValue(); //D02id判断是否为空 确认是否空闲 允许进片 String d02State = plcParameterObject.getPlcParameter("D02ID").getValue(); String d03State = plcParameterObject.getPlcParameter("D03State").getValue(); String d05State = plcParameterObject.getPlcParameter("D05State").getValue(); String mesD01Value = plcParameterObject.getPlcParameter("MESToD01").getValue(); String mesD04Value = plcParameterObject.getPlcParameter("MESToD04").getValue(); String mesD01Address = plcParameterObject.getPlcParameter("MESToD01").getAddress(); String mesD04Address = plcParameterObject.getPlcParameter("MESToD04").getAddress(); String d01ToMES = plcParameterObject.getPlcParameter("D01ToMES").getValue(); String d04ToMES = plcParameterObject.getPlcParameter("D04ToMES").getValue(); log.info("1、获取d01Id扫描ID为：{}，请求字为{};获取d04Id扫描ID为：{}，请求字为{};", d01Id, d01ToMES, d04Id, d04ToMES); if (StringUtils.isBlank(d01ToMES) && StringUtils.isBlank(d04ToMES)) { log.info("两条线未收到进片任务，结束本次扫描进卧转立任务"); return; } if (REQUEST_WORD.equals(d03State) && REQUEST_WORD.equals(d05State)) { log.info("两条线卧转立均在执行任务，结束本次扫描进卧转立任务"); return; } //按照线路及玻璃id获取相邻两块玻璃 卧转立上的玻璃: 状态为0不操作（D01送片，0不操作，1允许送片），请求字为1， （02玻璃id为空或者卧转立未启动） if (!REQUEST_WORD.equals(mesD01Value) && REQUEST_WORD.equals(d01ToMES) && (StringUtils.isBlank(d02State) || !REQUEST_WORD.equals(d03State))) { if (!d01GlassId.equals(d01Id)) { judgeGlassTypeStatus(d01Id, Const.A09_OUT_TARGET_POSITION, mesD01Address); d01GlassId = d01Id; } } // 状态为0不操作（D01送片，0不操作，1允许送片），请求字为1， 卧转立未启动 if (!REQUEST_WORD.equals(mesD04Value) && REQUEST_WORD.equals(d04ToMES) && !REQUEST_WORD.equals(d05State)) { if (!d04GlassId.equals(d04Id)) { judgeGlassTypeStatus(d04Id, Const.A10_OUT_TARGET_POSITION, mesD04Address); d04GlassId = d04Id; } } Date endDate = new Date(); log.info("大理片笼扫码任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime()); } @Scheduled(fixedDelay = 300) public void plcToHomeEdgFreeCarTask() { Date startDate = new Date(); log.info("大理片笼空车进片任务开始执行时间：{}", startDate); PlcParameterObject plcParameterObject = S7object.getinstance().PlcMesObject; String e01Status = plcParameterObject.getPlcParameter("E01State").getValue(); String d03ToMES = plcParameterObject.getPlcParameter("D03ToMES").getValue(); String d05ToMES = plcParameterObject.getPlcParameter("D05ToMES").getValue(); log.info("执行空车送片任务，获取到的大车状态为{}，卧转立状态分别为d03:{}，d05:{}", e01Status, d03ToMES, d05ToMES); if (REQUEST_WORD.equals(e01Status)) { Date endDate = new Date(); log.info("进片大车非空闲，结束送片任务，任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime()); return; } if (!REQUEST_WORD.equals(d03ToMES) && !REQUEST_WORD.equals(d05ToMES)) { Date endDate = new Date(); log.info("卧转立没有送片请求，结束送片任务，任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime()); return; } LambdaQueryWrapper wrapper = new LambdaQueryWrapper() .eq(BigStorageCageFeedTask::getTaskType, Const.BIG_STORAGE_IN_RUN) .and(e -> e.isNull(BigStorageCageFeedTask::getTargetSlot).or().eq(BigStorageCageFeedTask::getTargetSlot, Const.OUT_TARGET_POSITION_ZERO)) .eq(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_UP); //获取可以启动卧转立的任务线路 List feedTaskList = bigStorageCageFeedTaskService.list(wrapper); if (CollectionUtils.isNotEmpty(feedTaskList)) { if (feedTaskList.size() == 1) { computeTargetByLine(feedTaskList.get(0).getLine()); } else { //比较最早一片任务的版图id及版序 求出卧转立的线路 Integer startLine = getStartLine(); // //计算目标格子，发送启动任务 computeTargetByLine(startLine); } Date endDate = new Date(); log.info("大理片笼空车进片任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime()); return; } String d01Id = plcParameterObject.getPlcParameter("D01ID").getValue(); String d04Id = plcParameterObject.getPlcParameter("D04ID").getValue(); log.info("1、获取d01Id扫描ID为：{};获取d04Id扫描ID为：{};", d01Id, d04Id); //获取两条线卧转立是否有玻璃，且任务状态为1/2 List lineList = bigStorageCageFeedTaskService.querySitToUpGlass(); if (CollectionUtils.isEmpty(lineList)) { Date endDate = new Date(); log.info("两条线卧转立为空或者有进片任务未完成，结束任务，大理片笼空车进片任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime()); return; } Integer lineFirst = lineList.get(0); String lineGlassId = lineFirst.equals(Const.A09_OUT_TARGET_POSITION) ? d01Id : d04Id; //仅有一条先符合启动启动条件 if (lineList.size() == 1) { //如果进片请求但玻璃为空，计算任务表进片格子 发送进片任务 if (StringUtils.isEmpty(lineGlassId)) { computeTargetByLine(lineFirst); } else { //todo:计算扫描到的玻璃是否可以存进卧转立 //获取卧转立剩余宽度 if (computeIsRun(lineFirst, lineGlassId)) { computeTargetByLine(lineFirst); } } Date endDate = new Date(); log.info("大理片笼空车进片任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime()); return; } //两条先均可执行进片任务，判断两条线是否进片请求是否都为空 if (StringUtils.isBlank(d01Id) && StringUtils.isBlank(d04Id)) { //比较最早一片任务的版图id及版序 求出卧转立的线路 Integer line = getStartLine(); //计算任务表进片格子 发送进片任务 computeTargetByLine(line); Date endDate = new Date(); log.info("大理片笼空车进片任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime()); return; } else if (StringUtils.isNotBlank(d01Id) && StringUtils.isNotBlank(d04Id)) { // todo:两个都有进片玻璃 if (computeIsRun(Const.A09_OUT_TARGET_POSITION, d01Id) && computeIsRun(Const.A10_OUT_TARGET_POSITION, d04Id)) { //比较最早一片任务的版图id及版序 求出卧转立的线路 Integer line = getStartLine(); //计算任务表进片格子 发送进片任务 computeTargetByLine(line); } else if (computeIsRun(Const.A09_OUT_TARGET_POSITION, d01Id)) { computeTargetByLine(Const.A09_OUT_TARGET_POSITION); } else if (computeIsRun(Const.A10_OUT_TARGET_POSITION, d04Id)) { computeTargetByLine(Const.A10_OUT_TARGET_POSITION); } else { Date endDate = new Date(); log.info("大理片笼空车进片任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime()); return; } } else { //，或者仅有一条有玻璃 //一条线为空，一条线有进片请求有玻璃 int outLine = StringUtils.isBlank(d01Id) ? Const.A09_OUT_TARGET_POSITION : Const.A10_OUT_TARGET_POSITION; //获取进片请求玻璃为空的，计算任务表进片格子 发送进片任务 computeTargetByLine(outLine); } Date endDate = new Date(); log.info("大理片笼空车进片任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime()); } @Scheduled(fixedDelay = 2000) public void plcToHomeEdgOutTask() { Date startDate = new Date(); log.info("大理片笼空车进片任务开始执行时间：{}", startDate); PlcParameterObject plcMesObject = S7object.getinstance().PlcMesObject; String e02State = plcMesObject.getPlcParameter("E02State").getValue(); if (REQUEST_WORD.equals(e02State)) { log.info("出片忙碌，结束出片任务"); return; } String mesToPLCAddress = plcMesObject.getPlcParameter("MESToPLC").getAddress(); List outingList = bigStorageCageOutTaskService.list(new LambdaQueryWrapper() .eq(BigStorageCageOutTask::getTaskState, Const.BIG_STORAGE_OUT_NEW)); if (CollectionUtils.isNotEmpty(outingList)) { log.info("有正在执行出片的任务，结束当前出片线程"); return; } if (redisUtil.getCacheObject("temperingSwitch")) { //是否有正在钢化的玻璃 List temperingGlassInfoList = temperingGlassInfoService.selectJoinList(TemperingGlassInfo.class, new MPJLambdaWrapper() .selectAll(TemperingGlassInfo.class) .leftJoin(BigStorageCageOutTask.class, BigStorageCageOutTask::getGlassId, TemperingGlassInfo::getGlassId) .eq(TemperingGlassInfo::getState, Const.TEMPERING_NEW) .isNull(BigStorageCageOutTask::getGlassId) .orderBy(Boolean.TRUE, sequenceOrder, TemperingGlassInfo::getTemperingFeedSequence)); if (CollectionUtils.isNotEmpty(temperingGlassInfoList)) { log.info("有正在出片的钢化任务"); computeOutGlassInfo(temperingGlassInfoList, Boolean.TRUE, mesToPLCAddress); Date endDate = new Date(); log.info("大理片笼出片任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime()); return; } //是否有人工下片任务 有直接出 List artificialList = bigStorageCageDetailsService.list(new LambdaQueryWrapper() .eq(BigStorageCageDetails::getState, Const.GLASS_STATE_ARTIFICIAL).orderByDesc(BigStorageCageDetails::getWidth)); if (CollectionUtils.isNotEmpty(artificialList)) { computeOutGlassInfo(artificialList, Boolean.FALSE, mesToPLCAddress); Date endDate = new Date(); log.info("大理片笼出片任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime()); return; } //钢化优先：获取理片笼 玻璃小片 破损表 数量 判断笼内版图是否到齐 List temperingLayoutDTOList = bigStorageCageDetailsService.temperingIsAll(); if (CollectionUtils.isNotEmpty(temperingLayoutDTOList)) { //玻璃到齐包括已出片的 //到齐，将玻璃小片数据存入钢化小片表，逻辑生成出片任务 结束 for (TemperingLayoutDTO item : temperingLayoutDTOList) { List temperingGlassInfos = glassInfoService.selectJoinList(TemperingGlassInfo.class, JoinWrappers.lambda(GlassInfo.class) .selectAll(GlassInfo.class) .select("-1 as state") .selectAs(BigStorageCageDetails::getSlot, TemperingGlassInfo::getSlot) .innerJoin(BigStorageCageDetails.class, BigStorageCageDetails::getGlassId, GlassInfo::getGlassId) .eq(BigStorageCageDetails::getState, Const.GLASS_STATE_IN) .eq(GlassInfo::getTemperingLayoutId, item.getTemperingLayoutId()) .eq(GlassInfo::getEngineerId, item.getEngineerId()) .orderBy(Boolean.TRUE, sequenceOrder, GlassInfo::getTemperingFeedSequence)); if (CollectionUtils.isNotEmpty(temperingGlassInfos)) { temperingGlassInfoService.saveBatch(temperingGlassInfos); computeOutGlassInfo(temperingGlassInfoList, Boolean.TRUE, mesToPLCAddress); Date endDate = new Date(); log.info("大理片笼出片任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime()); return; } } } } //执行内部调度任务 List temperingOccupySlotList = bigStorageCageDetailsService.queryTemperingOccupySlot(); if (CollectionUtils.isNotEmpty(temperingOccupySlotList)) { loop: for (TemperingLayoutDTO temperingOccupySlot : temperingOccupySlotList) { List slotSequenceList = bigStorageCageDetailsService.queryGlassMaxAndMin(temperingOccupySlot.getEngineerId(), temperingOccupySlot.getTemperingLayoutId()); for (int i = 0; i < slotSequenceList.size() - 1; i++) { SlotSequenceDTO first = slotSequenceList.get(i); SlotSequenceDTO second = slotSequenceList.get(i + 1); int slotWidth = carWidth - first.getRemainWidth() - glassGap; if (first.getMinSequence() == second.getMaxSequence() + 1 && second.getRemainWidth() > slotWidth && slotWidth >= 0) { List list = bigStorageCageDetailsService.list(new LambdaQueryWrapper() .eq(BigStorageCageDetails::getSlot, first.getSlot()).eq(BigStorageCageDetails::getState, Const.GLASS_STATE_IN) .orderBy(Boolean.TRUE, sequenceOrder, BigStorageCageDetails::getTemperingFeedSequence)); if (CollectionUtils.isNotEmpty(list)) { List outTasks = new ArrayList<>(); int serialNumber = 1; for (BigStorageCageDetails item : list) { outTasks.add(new BigStorageCageOutTask(item.getGlassId(), first.getSlot(), second.getSlot(), item.getWidth() * 10, item.getHeight() * 10, 1, serialNumber++, Const.BIG_STORAGE_OUT_NEW)); } //新增调度任务 bigStorageCageOutTaskService.saveBatch(outTasks); //更新理片笼详情表调度的后的玻璃位置信息：生成任务后先将玻璃格子位置进行调整，玻璃状态改为调度中，新增调度完成任务，处理调度完成后玻璃状态改为100. List glassList = list.stream().map(BigStorageCageDetails::getGlassId).collect(Collectors.toList()); bigStorageCageDetailsService.update(new LambdaUpdateWrapper().set(BigStorageCageDetails::getState, Const.GLASS_STATE_SCHEDULE_ING) .set(BigStorageCageBaseInfo::getSlot, second.getSlot()).in(BigStorageCageDetails::getGlassId, glassList)); //两次更新笼子的剩余尺寸：第一次防止有玻璃继续进调度后的笼子，第二次更新：计算格子的实际尺寸 // 仅更新调度后的格子信息：起始格子完成后更新：防止调度出片过程中有新玻璃进入， updateSlotRemainBySlots(Arrays.asList(second.getSlot())); break loop; } } } } //向plc写入确认字 int returnData = 0; int count = 1; while (returnData == 0) { log.info("已向plc第{}次送协议", count); S7object.getinstance().plccontrol.writeWord(mesToPLCAddress, 1); returnData = S7object.getinstance().plccontrol.readWord(mesToPLCAddress, 1).get(0); log.info("已向plc第{}次发送出片任务确认，地址为：{},写入的内容为{}", count++, mesToPLCAddress, returnData); } Date endDate = new Date(); log.info("大理片笼出片任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime()); return; } } @Scheduled(fixedDelay = 300) public void updateInGlassStateTask() { Date startDate = new Date(); log.info("1、大理片笼进片完成后更新大理片笼数据任务开始执行时间：{}", startDate); //因为大理片笼和出片任务是两个库的数据，所以要分开查找 List list = bigStorageCageDetailsService.listObjs(new LambdaQueryWrapper() .select(BigStorageCageDetails::getGlassId).eq(BigStorageCageDetails::getState, Const.GLASS_STATE_NEW)); if (CollectionUtils.isNotEmpty(list)) { log.info("2、获取所有正在进片的玻璃信息id:{}", list); List glassIds = list.stream().map(String::valueOf).collect(Collectors.toList()); List inSuccessGlass = bigStorageCageFeedTaskService.list(new LambdaQueryWrapper() .in(BigStorageCageFeedTask::getGlassId, glassIds) .in(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_SLOT)); if (CollectionUtils.isNotEmpty(inSuccessGlass)) { log.info("3、获取进片已完成的玻璃信息id:{}", inSuccessGlass); List inSuccessGlassSlot = inSuccessGlass.stream().map(BigStorageCageFeedTask::getTargetSlot).collect(Collectors.toList()); List storageCageDTOList = inSuccessGlass.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:{}", inSuccessGlass); //更新理片笼玻璃尺寸 updateSlotRemainBySlots(inSuccessGlassSlot); log.info("5、大理片笼进片目标格子尺寸更新完成"); } } Date endDate = new Date(); log.info("end:大理片笼进片完成后更新大理片笼数据任务结束时间：{}，共耗时：{}ms,结束任务", endDate, endDate.getTime() - startDate.getTime()); return; } @Scheduled(fixedDelay = 300) public void updateOutGlassStateTask() { Date startDate = new Date(); log.info("1、大理片笼出片完成后更新大理片笼数据任务开始执行时间：{}", startDate); //因为大理片笼和出片任务是两个库的数据，所以要分开查找 List list = bigStorageCageDetailsService.listObjs(new LambdaQueryWrapper() .select(BigStorageCageDetails::getGlassId).eq(BigStorageCageDetails::getState, Const.GLASS_STATE_OUT_ING)); if (CollectionUtils.isNotEmpty(list)) { log.info("2、获取所有正在出片的玻璃信息id:{}", list); List glassIds = list.stream().map(String::valueOf).collect(Collectors.toList()); List outSuccessGlass = bigStorageCageOutTaskService.list(new LambdaQueryWrapper() .in(BigStorageCageOutTask::getGlassId, glassIds).in(BigStorageCageOutTask::getTaskState, Const.BIG_STORAGE_OUT_ALL)); if (CollectionUtils.isNotEmpty(outSuccessGlass)) { log.info("3、获取出片已完成的玻璃信息id:{}", outSuccessGlass); List storageCageDTOList = outSuccessGlass.stream().map(e -> { UpdateBigStorageCageDTO storageCageDTO = new UpdateBigStorageCageDTO(); storageCageDTO.setGlassId(e.getGlassId()); storageCageDTO.setTargetSlot(e.getStartSlot()); return storageCageDTO; }).collect(Collectors.toList()); bigStorageCageDetailsService.updateBySlot(storageCageDTOList, Const.GLASS_STATE_OUT); List outSuccessSlotList = outSuccessGlass.stream().map(BigStorageCageOutTask::getStartSlot).collect(Collectors.toList()); log.info("4、大理片笼出片状态已完成已完成的玻璃信息id:{}", outSuccessGlass); //更新理片笼玻璃尺寸 updateSlotRemainBySlots(outSuccessSlotList); log.info("5、大理片笼进片目标格子尺寸更新完成"); } } Date endDate = new Date(); log.info("end:大理片笼出片完成后更新大理片笼数据任务结束时间：{}，共耗时：{}ms,结束任务", endDate, endDate.getTime() - startDate.getTime()); return; } @Scheduled(fixedDelay = 300) public void updateScheduleGlassStateTask() { Date startDate = new Date(); log.info("1、大理片笼调度完成后更新大理片笼数据任务开始执行时间：{}", startDate); //因为大理片笼和调度任务是两个库的数据，所以要分开查找 List list = bigStorageCageDetailsService.listObjs(new LambdaQueryWrapper() .select(BigStorageCageDetails::getGlassId).eq(BigStorageCageDetails::getState, Const.GLASS_STATE_SCHEDULE_ING)); if (CollectionUtils.isNotEmpty(list)) { log.info("2、获取所有正在出片的玻璃信息id:{}", list); List glassIds = list.stream().map(String::valueOf).collect(Collectors.toList()); List scheduleSuccessGlass = bigStorageCageOutTaskService.list(new LambdaQueryWrapper() .in(BigStorageCageOutTask::getGlassId, glassIds).eq(BigStorageCageOutTask::getTaskState, Const.BIG_STORAGE_OUT_SUCCESS) .notIn(BigStorageCageOutTask::getEndSlot, Const.TEMPERING_OUT_TARGET_POSITION, Const.ARTIFICIAL_OUT_TARGET_POSITION)); if (CollectionUtils.isNotEmpty(scheduleSuccessGlass)) { log.info("3、获取调度已完成的玻璃信息id:{}", scheduleSuccessGlass); List storageCageDTOList = scheduleSuccessGlass.stream().map(e -> { UpdateBigStorageCageDTO storageCageDTO = new UpdateBigStorageCageDTO(); storageCageDTO.setGlassId(e.getGlassId()); storageCageDTO.setTargetSlot(e.getEndSlot()); return storageCageDTO; }).collect(Collectors.toList()); bigStorageCageDetailsService.updateBySlot(storageCageDTOList, Const.GLASS_STATE_IN); List scheduleSuccessGlassIds = scheduleSuccessGlass.stream().map(BigStorageCageOutTask::getGlassId).collect(Collectors.toList()); log.info("4、大理片笼出片状态已完成已完成的玻璃信息id:{}", scheduleSuccessGlassIds); //更新理片笼玻璃尺寸 List slotList = scheduleSuccessGlass.stream().map(BigStorageCageOutTask::getStartSlot).distinct().collect(Collectors.toList()); slotList.addAll(scheduleSuccessGlass.stream().map(BigStorageCageOutTask::getEndSlot).distinct().collect(Collectors.toList())); updateSlotRemainBySlots(slotList); log.info("5、大理片笼进片目标格子尺寸更新完成"); } } Date endDate = new Date(); log.info("end:大理片笼出片完成后更新大理片笼数据任务结束时间：{}，共耗时：{}ms,结束任务", endDate, endDate.getTime() - startDate.getTime()); return; } /** * 处理破损表任务 */ @Scheduled(fixedDelay = 300) public void dealDamageTask() { Date startDate = new Date(); log.info("大理片笼破损玻璃清除任务开始执行时间：{}", startDate); //获取进片任务表中状态为破损的数据 List inDamageTaskInfoList = bigStorageCageFeedTaskService.list(new LambdaQueryWrapper() .eq(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_DAMAGE)); if (CollectionUtils.isNotEmpty(inDamageTaskInfoList)) { log.info("获取进片任务表中破损的玻璃信息{}", inDamageTaskInfoList); bigStorageCageFeedTaskService.remove(new LambdaQueryWrapper().eq(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_DAMAGE)); //理片笼详情表数据状态更新 bigStorageCageDetailsService.update(new LambdaUpdateWrapper() .set(BigStorageCageDetails::getState, Const.GLASS_STATE_DAMAGE).in(BigStorageCageDetails::getGlassId, inDamageTaskInfoList.stream().map(BigStorageCageFeedTask::getGlassId).collect(Collectors.toList()))); //将破损信息新增入破损表 for (BigStorageCageFeedTask bigStorageCageFeedTask : inDamageTaskInfoList) { Damage damage = new Damage(); damage.setGlassId(bigStorageCageFeedTask.getGlassId()); damage.setLine(bigStorageCageFeedTask.getLine()); damage.setWorkingProcedure("冷加工"); damage.setRemark("进笼前卧转立"); damage.setStatus(2); damageService.insertDamage(damage); } log.info("进片任务执行完成"); } //获取出片任务表中状态为破损的数据 List outDamageTaskInfoList = bigStorageCageOutTaskService.list(new LambdaQueryWrapper() .eq(BigStorageCageOutTask::getTaskState, Const.BIG_STORAGE_OUT_DAMAGE)); if (CollectionUtils.isNotEmpty(outDamageTaskInfoList)) { log.info("获取出片任务表中破损的玻璃信息{}", outDamageTaskInfoList); bigStorageCageOutTaskService.remove(new LambdaQueryWrapper().eq(BigStorageCageOutTask::getTaskState, Const.BIG_STORAGE_IN_DAMAGE)); List glassIdList = outDamageTaskInfoList.stream().map(BigStorageCageOutTask::getGlassId).collect(Collectors.toList()); //移除钢化下片表数据 temperingGlassInfoService.update(new LambdaUpdateWrapper().in(TemperingGlassInfo::getGlassId, glassIdList) .set(TemperingGlassInfo::getState, Const.TEMPERING_DAMAGE)); //理片笼详情表数据状态更新 bigStorageCageDetailsService.update(new LambdaUpdateWrapper() .set(BigStorageCageDetails::getState, Const.GLASS_STATE_DAMAGE).in(BigStorageCageDetails::getGlassId, glassIdList)); //将破损信息新增入破损表 for (BigStorageCageOutTask bigStorageCageOutTask : outDamageTaskInfoList) { Damage damage = new Damage(); damage.setGlassId(bigStorageCageOutTask.getGlassId()); damage.setLine(bigStorageCageOutTask.getEndSlot()); damage.setWorkingProcedure("冷加工"); damage.setRemark("出片后卧转立"); damage.setStatus(2); damageService.insertDamage(damage); } log.info("出片任务执行完成"); } Date endDate = new Date(); log.info("大理片笼破损玻璃清除任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime()); return; } /** * 按照玻璃id判断玻璃状态及卧转立是否可直接启动 */ public Boolean judgeGlassTypeStatus(String glassId, Integer line, String mesAddress) { //1、获取任务表中相邻玻璃 List edgGlassTaskInfoList = edgGlassTaskInfoService.list(new LambdaQueryWrapper() .eq(EdgGlassTaskInfo::getLine, line) .apply("time >= (select time from edg_glass_task_info where glass_id = '" + glassId + "')") .orderByAsc(EdgGlassTaskInfo::getTime)); Assert.isFalse(CollectionUtils.isEmpty(edgGlassTaskInfoList), "识别玻璃信息未出现在尺寸表中,获取相邻两块玻璃失败"); //2、获取卧转立剩余宽度 BigStorageDTO sitToUpRemainWidth = bigStorageCageFeedTaskService.querySitToUpRemainWidth(line); Integer remainWidth; Integer glassCount; if (0 == sitToUpRemainWidth.getGlassCount()) { remainWidth = carWidth; glassCount = 0; } else { remainWidth = sitToUpRemainWidth.getWidth(); glassCount = sitToUpRemainWidth.getGlassCount(); } Boolean flag = Boolean.TRUE; //2、获取卧转立 Integer widthFirst = Math.max(edgGlassTaskInfoList.get(0).getWidth() / 10, edgGlassTaskInfoList.get(0).getHeight() / 10); Integer heightFirst = Math.min(edgGlassTaskInfoList.get(0).getWidth() / 10, edgGlassTaskInfoList.get(0).getHeight() / 10); if (edgGlassTaskInfoList.size() == 1) { if (remainWidth >= widthFirst) { if (glassCount < inCarMaxSize) { addFeedTask(glassId, line, Const.BIG_STORAGE_IN_WAIT, widthFirst, heightFirst); } else { addFeedTask(glassId, line, Const.BIG_STORAGE_IN_RUN, widthFirst, heightFirst); } } else { flag = Boolean.FALSE; } } else { Integer widthSecond = Math.max(edgGlassTaskInfoList.get(1).getWidth() / 10, edgGlassTaskInfoList.get(1).getHeight() / 10); Integer heightSecond = Math.min(edgGlassTaskInfoList.get(1).getWidth() / 10, edgGlassTaskInfoList.get(1).getHeight() / 10); if (remainWidth >= widthFirst) { if (remainWidth - widthFirst - glassGap >= widthSecond) { if (glassCount < inCarMaxSize) { addFeedTask(glassId, line, Const.BIG_STORAGE_IN_WAIT, widthFirst, heightSecond); } else { addFeedTask(glassId, line, Const.BIG_STORAGE_IN_RUN, widthFirst, heightSecond); } } else { addFeedTask(glassId, line, Const.BIG_STORAGE_IN_RUN, widthFirst, heightSecond); } } else { flag = Boolean.FALSE; } } //向plc发送进片确认 if (flag) { //向plc写入确认字 int returnData = 0; int count = 1; while (returnData == 0) { S7object.getinstance().plccontrol.writeWord(mesAddress, 1); returnData = S7object.getinstance().plccontrol.readWord(mesAddress, 1).get(0); log.info("进卧转立第{}次发送确认字完成，地址为：{},写入的内容为{}", count++, mesAddress, returnData); } } //记录无法放下玻璃，后续判断启动 return flag; } /** * 添加任务信息 */ private Boolean addFeedTask(String glassId, Integer line, Integer taskType, Integer width, Integer height) { BigStorageCageFeedTask bigStorageCageFeedTask = new BigStorageCageFeedTask(); bigStorageCageFeedTask.setGlassId(glassId); bigStorageCageFeedTask.setTaskState(Const.BIG_STORAGE_IN_NEW); bigStorageCageFeedTask.setLine(line); bigStorageCageFeedTask.setTaskType(taskType); bigStorageCageFeedTask.setWidth(width); bigStorageCageFeedTask.setHeight(height); bigStorageCageFeedTask.setCreateTime(new Date()); return bigStorageCageFeedTaskService.save(bigStorageCageFeedTask); } /** * 获取需要启动的线路：两条线都可启动 获取第一片玻璃版图id最小 版序最大的线路 * * @return 需要启动的线路 */ public Integer getStartLine() { List taskList = bigStorageCageFeedTaskService.list(new LambdaQueryWrapper() .inSql(BigStorageCageFeedTask::getId, "select min(id) from big_storage_cage_feed_task where task_state = 2" + "and (target_slot = 0 or target_slot is null) group by line")); Assert.isFalse(CollectionUtils.isEmpty(taskList), "卧转立两条线都没有玻璃进片任务"); Map taskMap = taskList.stream().collect(Collectors.toMap(BigStorageCageFeedTask::getGlassId, BigStorageCageFeedTask::getLine)); GlassInfo glassInfo = glassInfoService.getOne(new LambdaQueryWrapper() .in(GlassInfo::getGlassId, taskMap.keySet()) .orderByAsc(GlassInfo::getTemperingLayoutId) .orderBy(Boolean.TRUE, sequenceOrder, GlassInfo::getTemperingFeedSequence) .last("limit 1")); return taskMap.get(glassInfo.getGlassId()); } /** * 计算任务表进片线路的目标格子，并启动任务 */ public boolean computeTargetByLine(Integer line) { //1、获取任务表中的所有玻璃（指定线路且已经进卧转立完成） List taskList = bigStorageCageFeedTaskService.list(new LambdaQueryWrapper() .eq(BigStorageCageFeedTask::getLine, line) .and(e -> e.isNull(BigStorageCageFeedTask::getTargetSlot).or().eq(BigStorageCageFeedTask::getTargetSlot, Const.OUT_TARGET_POSITION_ZERO)) .in(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_UP_ALL) .orderByAsc(BigStorageCageFeedTask::getId)); //2、去笼子内查找是否可以继续存放的笼子 List glassIds = taskList.stream().map(BigStorageCageFeedTask::getGlassId).collect(Collectors.toList()); List glassInfos = glassInfoService.list(new LambdaQueryWrapper().in(GlassInfo::getGlassId, glassIds)); return computeIsTemperingTargetByLine(glassInfos, taskList, line); } /** * 是否钢化玻璃进笼目标位置 * * @param glassInfos 当条线卧转立所有玻璃 * @param taskList 当条线卧转立所有任务 * @param line 任务是哪条线 */ private boolean computeIsTemperingTargetByLine(List glassInfos, List taskList, Integer line) { //1、将玻璃信息集合转为glassid为key的map Map glassInfoMap = glassInfos.stream() .collect(Collectors.toMap(GlassInfo::getGlassId, p -> p)); for (BigStorageCageFeedTask e : taskList) { GlassInfo info = glassInfoMap.get(e.getGlassId()); if (info == null) { continue; } BigStorageCageDetails cageDetails = new BigStorageCageDetails(); BeanUtils.copyProperties(info, cageDetails); //2、获取目标格子信息 BigStorageDTO bigStorageDTO = bigStorageCageDetailsService.queryTargetSlotByTempering(info); //3、更新大理片笼表剩余宽度（更新大理片笼剩余尺寸移到进笼完成后执行） // bigStorageCageService.update(new LambdaUpdateWrapper().set(BigStorageCage::getRemainWidth, bigStorageDTO.getWidth() - info.getWidth() - glassGap) // .eq(BigStorageCage::getSlot, bigStorageDTO.getSlot())); //4、更新进片任务表，目标格子及状态（状态改为2 电气扫到自行处理） 遇到问题：无法批量更新，批量更新无法走指定从库 e.setTargetSlot(bigStorageDTO.getSlot()); bigStorageCageFeedTaskService.updateById(e); //5、将进片信息存入大理片笼详情表 cageDetails.setSlot(bigStorageDTO.getSlot()); cageDetails.setState(Const.GLASS_STATE_NEW); cageDetails.setDeviceId(bigStorageDTO.getDeviceId()); cageDetails.setGap(glassGap); bigStorageCageDetailsService.save(cageDetails); } sendTaskListToPLC(taskList, line); return Boolean.TRUE; } private void sendTaskListToPLC(List taskList, Integer line) { log.info("送片任务发送进片玻璃信息"); S7control s7control = S7object.getinstance().plccontrol; PlcParameterObject plcMesObject = S7object.getinstance().PlcMesObject; String mesD03Address = plcMesObject.getPlcParameter("MESToD03").getAddress(); String mesD05Address = plcMesObject.getPlcParameter("MESToD05").getAddress(); String outLine = line.equals(Const.A09_OUT_TARGET_POSITION) ? mesD03Address : mesD05Address; for (int i = 1; i <= taskList.size(); i++) { s7control.writeWord(plcMesObject.getPlcParameter("StartAddToImport" + i).getAddress(), taskList.get(i - 1).getLine()); s7control.writeWord(plcMesObject.getPlcParameter("TargetAddToImport" + i).getAddress(), taskList.get(i - 1).getTargetSlot()); log.info("向plc发送第{}片玻璃已完成", i); } int returnData = 0; int count = 1; while (returnData == 0) { s7control.writeWord(outLine, 2); returnData = s7control.readWord(outLine, 1).get(0); log.info("已向plc第{}次发送出片任务确认，地址为：{},写入的内容为{}", count++, outLine, returnData); } } private Boolean computeOutGlassInfo(List list, Boolean isTempering, String mesToPLCAddress) { //任务数据 获取车子存放玻璃最大数量 玻璃间隔 List bigStorageCageOutTaskList = new ArrayList<>(); //打车剩余尺寸 Integer remainWidth = carWidth; int trainNumber = 1; int serialNumber = 1; int maxX = 0; for (T e : list) { int maxLength = Math.max((int) e.getWidth(), (int) e.getHeight()); if (bigStorageCageOutTaskList.size() >= outCarMaxSize || maxLength > remainWidth) { remainWidth = carWidth; trainNumber = trainNumber + 1; serialNumber = 1; maxX = 0; continue; } remainWidth = remainWidth - maxLength - glassGap; if (isTempering) { int minLength = Math.min((int) e.getWidth(), (int) e.getHeight()); if (maxX + minLength <= xMaxSize) { bigStorageCageOutTaskList.add(new BigStorageCageOutTask(e.getGlassId(), e.getSlot(), Const.TEMPERING_OUT_TARGET_POSITION, e.getWidth() * 10, e.getHeight() * 10, trainNumber, serialNumber++, 1)); maxX = Math.max(maxX, e.getXCoordinate()); } else { remainWidth = carWidth; trainNumber = trainNumber + 1; serialNumber = 1; maxX = 0; continue; } } else { bigStorageCageOutTaskList.add(new BigStorageCageOutTask(e.getGlassId(), e.getSlot(), Const.ARTIFICIAL_OUT_TARGET_POSITION, e.getWidth() * 10, e.getHeight(), trainNumber, serialNumber++, 1)); } } Assert.isFalse(CollectionUtils.isEmpty(bigStorageCageOutTaskList), "未获取出片数据，结束出片任务"); log.info("获取出片任务数据{}条，执行保存", bigStorageCageOutTaskList.size()); bigStorageCageOutTaskService.saveBatch(bigStorageCageOutTaskList); List glassIds = bigStorageCageOutTaskList.stream().map(BigStorageCageOutTask::getGlassId).collect(Collectors.toList()); log.info("将出片玻璃{}玻璃状态改为已出片", glassIds); bigStorageCageDetailsService.update(new LambdaUpdateWrapper() .set(BigStorageCageDetails::getState, Const.GLASS_STATE_OUT_ING) .in(BigStorageCageDetails::getGlassId, glassIds)); int returnData = 0; int count = 1; while (returnData == 0) { S7object.getinstance().plccontrol.writeWord(mesToPLCAddress, 1); returnData = S7object.getinstance().plccontrol.readWord(mesToPLCAddress, 1).get(0); log.info("已向plc第{}次发送出片任务确认，地址为：{},写入的内容为{}", count++, mesToPLCAddress, returnData); } 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<>(); //是否存在有格子非空的玻璃 if (CollectionUtils.isNotEmpty(inSlotGlassList)) { //存在 将格子内的玻璃分别进行更新 slotRemainMap = inSlotGlassList.stream() .collect(Collectors.groupingBy(BigStorageCageDetails::getSlot, Collectors.summingDouble(item -> item.getWidth() + 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 (CollectionUtils.isNotEmpty(slotList)) { bigStorageCageService.update(new LambdaUpdateWrapper().set(BigStorageCage::getRemainWidth, slotWidth) .in(BigStorageCage::getSlot, slotList)); } } public Boolean computeIsRun(int line, String glassId) { //获取卧转立剩余宽度 BigStorageDTO sitToUpRemainWidth = bigStorageCageFeedTaskService.querySitToUpRemainWidth(line); if (sitToUpRemainWidth.getGlassCount() == 0) { return Boolean.FALSE; } //获取玻璃信息 GlassInfo glassInfo = glassInfoService.getOne(new LambdaQueryWrapper().eq(GlassInfo::getGlassId, glassId)); return sitToUpRemainWidth.getWidth() < Math.max(glassInfo.getWidth(), glassInfo.getHeight()); } }