派生自 HangZhouMes
hangzhoumesParent/common/servicebase/src/main/java/com/mes/common/config/Const.java
@@ -30,8 +30,18 @@ * A09出片目标位置 d02卧转立 钢化出片 3001 * A10出片目标位置 d05卧转立 人工出片 3002 */ public static final Integer TEMPERING_OUT_TARGET_POSITION = 3001; public static final Integer ARTIFICIAL_OUT_TARGET_POSITION = 3002; // public static final Integer TEMPERING_OUT_TARGET_POSITION = 3001; // public static final Integer ARTIFICIAL_OUT_TARGET_POSITION = 3002; // public static final List<Integer> OUT_TARGET_POSITION_ALL = Arrays.asList(3001, 3002); /** * 义乌磨边线 * A09出片目标位置 d02卧转立 钢化出片 930 * A10出片目标位置 d05卧转立 人工出片 931 */ public static final Integer TEMPERING_OUT_TARGET_POSITION = 930; public static final Integer ARTIFICIAL_OUT_TARGET_POSITION = 931; public static final List<Integer> OUT_TARGET_POSITION_ALL = Arrays.asList(930, 931); /** * 卧式理片笼详情表玻璃状态 @@ -103,8 +113,10 @@ */ public static final Integer BIG_STORAGE_BEFORE_IN = 1; public static final Integer BIG_STORAGE_BEFORE_OUT = 2; public static final Integer BIG_STORAGE_AFTER_IN = 3; public static final Integer BIG_STORAGE_AFTER_OUT = 4; public static final Integer BIG_STORAGE_BEFORE_DISPATCH = 3; public static final Integer BIG_STORAGE_AFTER_IN = 4; public static final Integer BIG_STORAGE_AFTER_OUT = 5; public static final Integer BIG_STORAGE_AFTER_DISPATCH = 6; /** * 大理片笼请求 hangzhoumesParent/common/servicebase/src/main/java/com/mes/temperingglass/entity/TemperingGlass.java
New file @@ -0,0 +1,82 @@ package com.mes.temperingglass.entity; import com.baomidou.mybatisplus.annotation.IdType; import com.baomidou.mybatisplus.annotation.TableId; import com.baomidou.mybatisplus.annotation.TableName; import com.mes.base.entity.BigStorageCageBaseInfo; import lombok.Data; import java.io.Serializable; /** * (TemperingGlassInfo)表实体类 * * @author makejava * @since 2024-11-18 08:36:18 */ @Data @TableName("tempering_glass_info") public class TemperingGlass extends BigStorageCageBaseInfo implements Serializable { /** * 钢化小片信息表id */ @TableId(value = "id", type = IdType.AUTO) private Long id; /** * 流程卡 */ private String flowCardId; /** * 流程卡玻璃类型 */ private Integer glassType; /** * 厚度 */ private Double thickness; /** * 膜系 */ private String filmsid; /** * 总层数 */ private Integer totalLayer; /** * 层数 */ private Integer layer; /** * 钢化是否接受横放 */ private Integer ishorizontal; /** * 钢化版图id */ private Integer temperingLayoutId; /** * 钢化版图片序 */ private Integer temperingFeedSequence; /** * 旋转角度（逆时针） */ private Integer angle; /** * 工程号 */ private String engineerId; /** * 状态 */ private Integer state; /** * 钢化类型 */ private Integer temperingType; private String deleted; }
New file @@ -0,0 +1,15 @@ package com.mes.temperingglass.mapper; import com.github.yulichang.base.MPJBaseMapper; import com.mes.temperingglass.entity.TemperingGlass; /** * (TemperingGlassInfo)表数据库访问层 * * @author makejava * @since 2024-11-18 08:36:17 */ public interface TemperingGlassMapper extends MPJBaseMapper<TemperingGlass> { }
New file @@ -0,0 +1,15 @@ package com.mes.temperingglass.service; import com.github.yulichang.base.MPJBaseService; import com.mes.temperingglass.entity.TemperingGlass; /** * (TemperingGlassInfo)表服务接口 * * @author makejava * @since 2024-11-18 08:36:18 */ public interface TemperingGlassService extends MPJBaseService<TemperingGlass> { }
New file @@ -0,0 +1,19 @@ package com.mes.temperingglass.service.impl; import com.github.yulichang.base.MPJBaseServiceImpl; import com.mes.temperingglass.entity.TemperingGlass; import com.mes.temperingglass.mapper.TemperingGlassMapper; import com.mes.temperingglass.service.TemperingGlassService; import org.springframework.stereotype.Service; /** * (TemperingGlass)表服务实现类 * * @author makejava * @since 2024-11-18 08:36:18 */ @Service public class TemperingGlassServiceImpl extends MPJBaseServiceImpl<TemperingGlassMapper, TemperingGlass> implements TemperingGlassService { }
@@ -1,26 +1,36 @@ 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.query.QueryWrapper; import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper; import com.kangaroohy.milo.model.ReadWriteEntity; import com.kangaroohy.milo.runner.subscription.SubscriptionCallback; import com.kangaroohy.milo.service.MiloService; import com.mes.common.config.Const; import com.mes.edgglasstaskqueueinfo.entity.EdgGlassTaskQueueInfo; import com.mes.edgglasstaskqueueinfo.service.EdgGlassTaskQueueInfoService; import com.mes.edgstoragecage.entity.EdgStorageCage; import com.mes.edgstoragecage.entity.EdgStorageCageDetails; import com.mes.edgstoragecage.service.EdgStorageCageDetailsService; import com.mes.edgstoragecage.service.EdgStorageCageService; import com.mes.glassinfo.entity.GlassInfo; import com.mes.glassinfo.service.GlassInfoService; import com.mes.opctask.entity.EdgStorageDeviceTask; import com.mes.opctask.entity.EdgStorageDeviceTaskHistory; import com.mes.opctask.service.EdgStorageDeviceTaskHistoryService; import com.mes.opctask.service.EdgStorageDeviceTaskService; 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 javax.annotation.Resource; import java.util.ArrayList; import java.util.Arrays; import java.util.Date; import java.util.List; /** @@ -40,32 +50,97 @@ MiloService miloService; @Resource(name = "cacheGlassStartCallback") SubscriptionCallback cacheGlassStartCallback; @Resource(name = "cacheGlassTestCallback") SubscriptionCallback cacheGlassTestCallback; // @Resource(name = "cacheGlassStartCallback") // SubscriptionCallback cacheGlassStartCallback; // // @Resource(name = "cacheGlassTestCallback") // SubscriptionCallback cacheGlassTestCallback; @Resource EdgStorageDeviceTaskService edgStorageDeviceTaskService; @Resource EdgGlassTaskQueueInfoService edgGlassTaskQueueInfoService; @Resource GlassInfoService glassInfoService; @Resource EdgStorageCageDetailsService edgStorageCageDetailsService; @Resource EdgStorageCageService edgStorageCageService; @Resource EdgStorageDeviceTaskHistoryService edgStorageDeviceTaskHistoryService; @Value("${mes.glassGap}") private int glassGap; @Value("${mes.threshold}") private int threshold; @Value("${mes.cellLength}") private int cellLength; private String glassIdOne = ""; private String glassIdTwo = ""; @Scheduled(fixedDelay = Long.MAX_VALUE) public void startOneOpcTask() throws Exception { miloService.subscriptionFromOpcUa(Arrays.asList("mes.WL1.edg_storage_device_one_task[1].task_state"), cacheGlassStartCallback); // @Scheduled(fixedDelay = Long.MAX_VALUE) // public void startOneOpcTask() throws Exception { // miloService.subscriptionFromOpcUa(Arrays.asList("mes.WL1.edg_storage_device_one_task[1].task_state"), cacheGlassStartCallback); // } // // @Scheduled(fixedDelay = Long.MAX_VALUE) // public void startTwoOpcTask() throws Exception { // miloService.subscriptionFromOpcUa(Arrays.asList("mes.WL2.edg_storage_device_two_task[1].task_state"), cacheGlassStartCallback); // } @Scheduled(fixedDelay = 1000) public void startOneOpcTask() { startOneOpcTaskChild(EDG_STORAGE_DEVICE_ONE_TASK, 1); } @Scheduled(fixedDelay = Long.MAX_VALUE) public void startTwoOpcTask() throws Exception { miloService.subscriptionFromOpcUa(Arrays.asList("mes.WL2.edg_storage_device_two_task[1].task_state", "PLC.WL2.plc_task_tate"), cacheGlassStartCallback); @Scheduled(fixedDelay = 1000) public void startTwoOpcTask() { startOneOpcTaskChild(EDG_STORAGE_DEVICE_TWO_TASK, 2); } private void startOneOpcTaskChild(String tableName, int device) { EdgStorageDeviceTask task = edgStorageDeviceTaskService.queryTaskMessage(tableName); try { if (task == null) { log.info("任务表基础数据录入失败，请检查数据是否录入成功"); return; } if (task.getTaskState() == 2) { //防止出片任务且笼前有玻璃的情况，将进片id置空，即出片仅考虑笼内的玻璃 task.setGlassIdIn(""); } int request = task.getTaskState(); log.info("开始执行任务，任务请信息为{}", task); if (request == 0) { log.info("未收到任务请求，结束本次任务"); } else if (request == 1) { //进片任务 log.info("进片任务：进片玻璃id为：{}", task.getGlassIdIn()); intoTask(task, tableName, device); } else if (request == 2) { //出片任务 outTask(task, tableName, device); } else if (request == 3) { //直通任务 if (!outTask(task, tableName, device)) { intoTask(task, tableName, device); } } else if (request == 4) { log.info("将启动子改为0"); task.setTaskRunning(Const.GLASS_CACHE_TYPE_RUNNING); edgStorageDeviceTaskService.updateTaskMessage(tableName, task); } else { finishTask(task, tableName); } } catch (Exception e) { log.info("执行任务过程中发生异常，任务字{}，{}", task.getTaskState(), e.getMessage()); log.info("将启动子改为0"); task.setTaskState(Const.GLASS_CACHE_TYPE_EMPTY); edgStorageDeviceTaskService.updateTaskMessage(tableName, task); } } @Scheduled(fixedDelay = 1000) public void edgOneOpcTask() throws Exception { @@ -97,20 +172,20 @@ } String toEndingId = glassInfo.getTemperingLayoutId() + "" + glassInfo.getTemperingFeedSequence(); List<ReadWriteEntity> list = new ArrayList<>(); // list.add(generateReadWriteEntity("PLC.MB" + cell + ".mesControl", true)); list.add(generateReadWriteEntity("PLC.MB" + cell + ".glassId", Integer.parseInt(toEndingId))); list.add(generateReadWriteEntity("PLC.MB" + cell + ".toEdingId", Integer.parseInt(toEndingId))); list.add(generateReadWriteEntity("PLC.MB" + cell + ".width", (int) Math.max(glassInfo.getWidth() * 10, glassInfo.getHeight() * 10))); list.add(generateReadWriteEntity("PLC.MB" + cell + ".height", (int) Math.min(glassInfo.getWidth() * 10, glassInfo.getHeight() * 10))); // list.add(generateReadWriteEntity("MB" + cell + ".MB" + cell + ".mesControl", true)); list.add(generateReadWriteEntity("MB" + cell + ".MB" + cell + ".glassId", Integer.parseInt(toEndingId))); list.add(generateReadWriteEntity("MB" + cell + ".MB" + cell + ".toEdingId", Integer.parseInt(toEndingId))); list.add(generateReadWriteEntity("MB" + cell + ".MB" + cell + ".width", (int) Math.max(glassInfo.getWidth() * 10, glassInfo.getHeight() * 10))); list.add(generateReadWriteEntity("MB" + cell + ".MB" + cell + ".height", (int) Math.min(glassInfo.getWidth() * 10, glassInfo.getHeight() * 10))); miloService.writeToOpcUa(list); miloService.writeToOpcWord(generateReadWriteEntity("PLC.MB" + cell + ".thickness", (int) glassInfo.getThickness() * 10)); miloService.writeToOpcWord(generateReadWriteEntity("MB" + cell + ".MB" + cell + ".thickness", (int) glassInfo.getThickness() * 10)); //修改磨边对列中的磨边线路及状态 edgGlassTaskQueueInfoService.update(new LambdaUpdateWrapper<EdgGlassTaskQueueInfo>() .set(EdgGlassTaskQueueInfo::getLine, cell) .set(EdgGlassTaskQueueInfo::getState, 1) .set(EdgGlassTaskQueueInfo::getState, Const.EDG_GLASS_START) .eq(EdgGlassTaskQueueInfo::getGlassId, glassId) .eq(EdgGlassTaskQueueInfo::getState, Const.GLASS_STATE_NEW)); .eq(EdgGlassTaskQueueInfo::getState, Const.EDG_GLASS_BEFORE)); if (cell == 1) { glassIdOne = glassId; } else { @@ -119,6 +194,348 @@ } private boolean intoTask(EdgStorageDeviceTask task, String tableName, int deviceId) { //获取玻璃的基本信息 GlassInfo glassInfo = glassInfoService.getOne(new LambdaQueryWrapper<GlassInfo>().eq(GlassInfo::getGlassId, task.getGlassIdIn())); if (null == glassInfo) { log.info("进片玻璃信息不存在，玻璃id:{}", task.getGlassIdIn()); return Boolean.FALSE; } //获取当前进片玻璃id和进片格子 相同尺寸可以放下的格子 EdgStorageCage edgStorageCage = edgStorageCageService.getEdgStorageCageBySize(deviceId, glassInfo.getWidth(), glassInfo.getHeight(), task.getCurrentCell()); if (edgStorageCage == null) { log.info("相同尺寸可以放下的格子未找到，格子id:{}", task.getCurrentCell()); // SELECT * from edg_storage_cage where device_id = 1 and remain_width > 1000 order by abs(slot - 10) List<EdgStorageCage> storageCageList = edgStorageCageService.list(new LambdaQueryWrapper<EdgStorageCage>() .eq(EdgStorageCage::getDeviceId, deviceId) .eq(EdgStorageCage::getEnableState, Const.SLOT_ON) .ge(EdgStorageCage::getRemainWidth, Math.max(glassInfo.getWidth(), glassInfo.getHeight())).last("order by abs(slot - " + task.getCurrentCell() + ")")); // //直通任务 // if (flag && CollectionUtil.isNotEmpty(emptyList)) { // return emptyList.get(0); // } if (CollectionUtil.isEmpty(storageCageList) || storageCageList.size() == 1) { log.info("没有多余的空格子"); return Boolean.FALSE; } edgStorageCage = storageCageList.get(0); } log.info("4、将玻璃信息插入卧式理片笼,当前玻璃信息:{}", glassInfo); EdgStorageCageDetails details = new EdgStorageCageDetails(); BeanUtils.copyProperties(glassInfo, details); details.setState(Const.GLASS_STATE_IN); details.setSlot(edgStorageCage.getSlot()); details.setDeviceId(edgStorageCage.getDeviceId()); edgStorageCageDetailsService.save(details); //更新任务信息 task.setStartCell(edgStorageCage.getSlot()); task.setTaskRunning(Const.GLASS_CACHE_TYPE_IN); edgStorageDeviceTaskService.updateTaskMessage(tableName, task); saveHistoryTask(task); return Boolean.TRUE; } private boolean outTask(EdgStorageDeviceTask task, String tableName, int deviceId) { EdgStorageCageDetails edgStorageCageDetails = null; //笼内是版图相差是否超过阈值 boolean flag = queryMaxMinDiff(threshold); if (flag) { EdgStorageCageDetails minEdgDetails = edgStorageCageDetailsService.getOne(new LambdaQueryWrapper<EdgStorageCageDetails>() .inSql(EdgStorageCageDetails::getSlot, "select slot from edg_storage_cage where enable_state = " + Const.SLOT_ON) .eq(EdgStorageCageDetails::getState, Const.GLASS_STATE_IN) .eq(EdgStorageCageDetails::getDeviceId, deviceId) .orderByAsc(EdgStorageCageDetails::getTemperingLayoutId) .orderBy(Boolean.TRUE, Boolean.TRUE, EdgStorageCageDetails::getTemperingFeedSequence) .last("limit 1")); // select * from edg_storage_cage_details where width = 551 and height = 1151 and id in (select min(id ) from edg_storage_cage_details where state = 100 group by slot ) edgStorageCageDetails = edgStorageCageDetailsService.getOne(new LambdaQueryWrapper<EdgStorageCageDetails>() .eq(EdgStorageCageDetails::getWidth, minEdgDetails.getWidth()) .eq(EdgStorageCageDetails::getHeight, minEdgDetails.getHeight()) .eq(EdgStorageCageDetails::getDeviceId, deviceId) .inSql(EdgStorageCageDetails::getId, "select min(id) from edg_storage_cage_details where state = 100 group by slot ") .last("order by abs(slot - " + task.getCurrentCell() + ") asc limit 1") ); //给直通任务 if (null == edgStorageCageDetails && StringUtils.isNotBlank(task.getGlassIdIn())) { GlassInfo glassInInfo = glassInfoService.getOne(new LambdaQueryWrapper<GlassInfo>() .eq(GlassInfo::getGlassId, task.getGlassIdIn()) .eq(GlassInfo::getWidth, minEdgDetails.getWidth()) .eq(GlassInfo::getHeight, minEdgDetails.getHeight())); if (null != glassInInfo) { edgStorageCageDetails = new EdgStorageCageDetails(); BeanUtils.copyProperties(glassInInfo, edgStorageCageDetails); } } if (null == edgStorageCageDetails) { edgStorageCageDetails = edgStorageCageDetailsService.getOne(new LambdaQueryWrapper<EdgStorageCageDetails>() .eq(EdgStorageCageDetails::getState, Const.GLASS_STATE_IN) .eq(EdgStorageCageDetails::getDeviceId, deviceId) .eq(EdgStorageCageDetails::getSlot, minEdgDetails.getSlot()) .orderByAsc(EdgStorageCageDetails::getId) .last("limit 1") ); } } if (null == edgStorageCageDetails) { // 获取上次任务 // 获取历史表中上次任务最后一片尺寸 EdgStorageDeviceTaskHistory edgeData = edgStorageDeviceTaskHistoryService.getOne(new LambdaQueryWrapper<EdgStorageDeviceTaskHistory>() .eq(EdgStorageDeviceTaskHistory::getTaskState, Const.RAW_GLASS_TASK_SUCCESS) .in(EdgStorageDeviceTaskHistory::getTaskType, Const.GLASS_CACHE_TYPE_OUT, Const.GLASS_CACHE_TYPE_THROUGH) .orderByDesc(EdgStorageDeviceTaskHistory::getId).last("limit 1")); if (null != edgeData) { GlassInfo glassOutInfo = glassInfoService.getOne(new LambdaQueryWrapper<GlassInfo>().eq(GlassInfo::getGlassId, edgeData.getGlassIdOut())); //笼内的玻璃的尺寸是否和上一次任务一致 edgStorageCageDetails = edgStorageCageDetailsService.queryEdgStorageDetailsBySize(deviceId, task.getCurrentCell(), glassOutInfo.getWidth(), glassOutInfo.getHeight()); if (null == edgStorageCageDetails && StringUtils.isNotBlank(task.getGlassIdIn())) { GlassInfo glassInInfo = glassInfoService.getOne(new LambdaQueryWrapper<GlassInfo>() .eq(GlassInfo::getGlassId, task.getGlassIdIn()) .eq(GlassInfo::getWidth, glassOutInfo.getWidth()) .eq(GlassInfo::getHeight, glassOutInfo.getHeight())); if (null != glassInInfo) { edgStorageCageDetails = new EdgStorageCageDetails(); BeanUtils.copyProperties(glassInInfo, edgStorageCageDetails); } } } } if (null == edgStorageCageDetails) { edgStorageCageDetails = edgStorageCageDetailsService.queryEdgStorageDetailsBySize(deviceId, task.getCurrentCell(), 0, 0); } if (edgStorageCageDetails == null && StringUtils.isNotBlank(task.getGlassIdIn())) { //和上次任务不存在相同尺寸 GlassInfo glassInInfo = glassInfoService.getOne(new LambdaQueryWrapper<GlassInfo>().eq(GlassInfo::getGlassId, task.getGlassIdIn())); edgStorageCageDetails = new EdgStorageCageDetails(); BeanUtils.copyProperties(glassInInfo, edgStorageCageDetails); } if (edgStorageCageDetails == null) { //和上次任务不存在相同尺寸 log.info("笼内没有玻璃了"); return Boolean.FALSE; } int taskType = Const.GLASS_CACHE_TYPE_OUT; String glassId = edgStorageCageDetails.getGlassId(); if (glassId.equals(task.getGlassIdIn())) { if (3 != task.getTaskState()) { return Boolean.FALSE; } log.info("5、直通任务,将玻璃信息插入卧式理片笼,当前玻璃信息:{}", edgStorageCageDetails); //玻璃信息替换 String glassIdChange = queryAndChangeGlass(glassId); //处理在卧理内的玻璃信息：笼内的数据处理 queryEdgAndChangeGlass(edgStorageCageDetails.getGlassId(), glassIdChange); if (StringUtils.isNotBlank(glassIdChange)) { edgStorageCageDetails = new EdgStorageCageDetails(); GlassInfo one = glassInfoService.getOne(new LambdaQueryWrapper<GlassInfo>().eq(GlassInfo::getGlassId, glassId)); BeanUtils.copyProperties(one, edgStorageCageDetails); } EdgStorageCage storageCage = edgStorageCageService.getOne(new LambdaQueryWrapper<EdgStorageCage>() .eq(EdgStorageCage::getDeviceId, deviceId) .eq(EdgStorageCage::getEnableState, Const.SLOT_ON) .ge(EdgStorageCage::getRemainWidth, cellLength) .last("order by abs(slot - " + task.getCurrentCell() + ") limit 1")); Assert.isTrue(null != storageCage, "格子已满,无法执行直通任务"); log.info("3、查询卧式理片笼里面的空格:{}", storageCage); edgStorageCageDetails.setSlot(storageCage.getSlot()); edgStorageCageDetails.setDeviceId(storageCage.getDeviceId()); edgStorageCageDetails.setState(Const.GLASS_STATE_OUT); edgStorageCageDetailsService.save(edgStorageCageDetails); taskType = Const.GLASS_CACHE_TYPE_THROUGH; } else { log.info("5、非直通任务,将玻璃信息插入卧式理片笼,当前玻璃信息:{}", edgStorageCageDetails); if (!edgStorageCageDetails.getSlot().equals(task.getCurrentCell())) { EdgStorageCageDetails currentGlass = edgStorageCageDetailsService.getOne(new LambdaQueryWrapper<EdgStorageCageDetails>() .eq(EdgStorageCageDetails::getState, Const.GLASS_STATE_IN) .eq(EdgStorageCageDetails::getDeviceId, deviceId) .eq(EdgStorageCageDetails::getSlot, task.getCurrentCell()).eq(EdgStorageCageDetails::getWidth, edgStorageCageDetails.getWidth()) .eq(EdgStorageCageDetails::getHeight, edgStorageCageDetails.getHeight()).eq(EdgStorageCageDetails::getThickness, edgStorageCageDetails.getThickness()) .orderByAsc(EdgStorageCageDetails::getId).last("limit 1") ); if (null != currentGlass) { edgStorageCageDetails = currentGlass; } } //玻璃信息替换 String glassIdChange = queryAndChangeGlass(edgStorageCageDetails.getGlassId()); //处理在卧理内的玻璃信息：笼内的数据处理 queryEdgAndChangeGlass(edgStorageCageDetails.getGlassId(), glassIdChange); LambdaUpdateWrapper<EdgStorageCageDetails> wrapper = new LambdaUpdateWrapper<>(); wrapper.eq(EdgStorageCageDetails::getGlassId, edgStorageCageDetails.getGlassId()).set(EdgStorageCageDetails::getState, Const.GLASS_STATE_OUT); edgStorageCageDetailsService.update(wrapper); log.info("5、更新出片玻璃的状态为{}", Const.GLASS_STATE_OUT); } //生成出片任务 task.setGlassIdOut(edgStorageCageDetails.getGlassId()); task.setStartCell(edgStorageCageDetails.getSlot()); task.setTaskRunning(taskType); edgStorageDeviceTaskService.updateTaskMessage(tableName, task); saveHistoryTask(task); //更新详情表任务出片中 edgStorageCageDetailsService.update(new LambdaUpdateWrapper<EdgStorageCageDetails>() .set(EdgStorageCageDetails::getState, Const.GLASS_STATE_OUT) .eq(EdgStorageCageDetails::getGlassId, edgStorageCageDetails.getGlassId())); //磨边对列表新增一条数据 EdgGlassTaskQueueInfo edgInfo = new EdgGlassTaskQueueInfo(); BeanUtils.copyProperties(task, edgInfo); edgInfo.setGlassId(edgStorageCageDetails.getGlassId()); edgInfo.setCreateTime(new Date()); edgInfo.setWidth((int) edgStorageCageDetails.getWidth()); edgInfo.setHeight((int) edgStorageCageDetails.getHeight()); edgInfo.setThickness((int) edgStorageCageDetails.getThickness()); edgInfo.setState(Const.EDG_GLASS_BEFORE); edgGlassTaskQueueInfoService.save(edgInfo); return Boolean.TRUE; } private boolean finishTask(EdgStorageDeviceTask task, String tableName) { log.info("当前任务信息为：{}", task); if (task.getTaskState() <= 4 && task.getTaskRunning() == 0) { log.info("有正在执行的任务或这任务已执行任务状态{}，任务启动情况{}，结束", task.getTaskState(), task.getTaskRunning()); return Boolean.FALSE; } Integer cell = task.getStartCell(); Integer state = task.getTaskState(); task.setTaskRunning(Const.GLASS_CACHE_TYPE_EMPTY); task.setGlassIdOut(""); task.setStartCell(0); edgStorageDeviceTaskService.updateTaskMessage(tableName, task); edgStorageDeviceTaskHistoryService.update(new LambdaUpdateWrapper<EdgStorageDeviceTaskHistory>() .eq(EdgStorageDeviceTaskHistory::getTaskState, Const.RAW_GLASS_TASK_NEW) .set(EdgStorageDeviceTaskHistory::getTaskState, Const.GLASS_CACHE_TYPE_FINISH.equals(state) ? Const.RAW_GLASS_TASK_SUCCESS : Const.RAW_GLASS_TASK_FAILURE) ); int device = tableName.equals("edg_storage_device_one_task") ? 1 : 2; updateCellRemainWidth(cell, device); return Boolean.TRUE; } /** * 查询玻璃并进行交换 * * @param glassId * @return */ public String queryAndChangeGlass(String glassId) { GlassInfo glassInfo = glassInfoService.getOne(new LambdaQueryWrapper<GlassInfo>().eq(GlassInfo::getGlassId, glassId)); // .inSql(GlassInfo::getEngineerId, "select engineer_id from engineering where state = 1")); Assert.isFalse(null == glassInfo, "玻璃信息不存在"); //按照玻璃尺寸 LambdaQueryWrapper<GlassInfo> queryWrapper = new LambdaQueryWrapper<GlassInfo>() .eq(GlassInfo::getWidth, glassInfo.getWidth()) .eq(GlassInfo::getHeight, glassInfo.getHeight()) .eq(GlassInfo::getThickness, glassInfo.getThickness()) .eq(GlassInfo::getFilmsid, glassInfo.getFilmsid()) .eq(GlassInfo::getFlowCardId, glassInfo.getFlowCardId()) .eq(GlassInfo::getTotalLayer, glassInfo.getTotalLayer()) .eq(GlassInfo::getLayer, glassInfo.getLayer()) .eq(GlassInfo::getEngineerId, glassInfo.getEngineerId()) .notInSql(GlassInfo::getGlassId, "select distinct glass_id from edg_storage_cage_details " + "where engineer_id = '" + glassInfo.getEngineerId() + "' and width = " + glassInfo.getWidth() + " and height = " + glassInfo.getHeight() + " and state != 100") .orderByAsc(GlassInfo::getTemperingLayoutId) .orderBy(Boolean.TRUE, Boolean.TRUE, GlassInfo::getTemperingFeedSequence) .last("Limit 1"); GlassInfo swapGlassInfo = glassInfoService.getOne(queryWrapper); if (swapGlassInfo != null && !glassInfo.getGlassId().equals(swapGlassInfo.getGlassId())) { String swapGlassId = swapGlassInfo.getGlassId(); log.info("将玻璃{}和玻璃{}，信息互换,进玻璃 {}", glassInfo, swapGlassInfo, swapGlassInfo); swapGlassInfo.setGlassId(glassId); glassInfo.setGlassId(swapGlassId); glassInfoService.updateById(swapGlassInfo); glassInfoService.updateById(glassInfo); return swapGlassId; } return ""; } /** * 查询卧式理片玻璃并进行交换 * * @param glassId * @return */ public void queryEdgAndChangeGlass(String glassId, String swapGlassId) { if (StringUtils.isBlank(swapGlassId)) { log.info("当前出笼玻璃不存在需要替换的玻璃"); return; } //获取待出笼的玻璃 EdgStorageCageDetails glassInfo = edgStorageCageDetailsService.getOne(new LambdaQueryWrapper<EdgStorageCageDetails>() .eq(EdgStorageCageDetails::getGlassId, glassId).eq(EdgStorageCageDetails::getState, Const.GLASS_STATE_IN)); // 获取待出笼的玻璃需要替换的玻璃信息 EdgStorageCageDetails swapGlassDetailInfo = edgStorageCageDetailsService.getOne(new LambdaQueryWrapper<EdgStorageCageDetails>() .eq(EdgStorageCageDetails::getGlassId, swapGlassId).eq(EdgStorageCageDetails::getState, Const.GLASS_STATE_IN)); // 玻璃小片表中玻璃已经替换，更新卧理笼内现有的准备出笼的玻璃信息， if (null == swapGlassDetailInfo) { GlassInfo glassInfoBase = glassInfoService.getOne(new LambdaQueryWrapper<GlassInfo>() .eq(GlassInfo::getGlassId, glassId)); //需要替换的玻璃为存进卧理，仅需更新当前需要出笼的玻璃信息即可 edgStorageCageDetailsService.update(new LambdaUpdateWrapper<EdgStorageCageDetails>() .eq(EdgStorageCageDetails::getGlassId, glassId) .set(EdgStorageCageDetails::getTemperingLayoutId, glassInfoBase.getTemperingLayoutId()) .set(EdgStorageCageDetails::getTemperingFeedSequence, glassInfoBase.getTemperingFeedSequence())); } else { //需要替换的玻璃都在卧理内，按照玻璃id对调玻璃信息：对调玻璃id即可 edgStorageCageDetailsService.update(new LambdaUpdateWrapper<EdgStorageCageDetails>() .eq(EdgStorageCageDetails::getId, glassInfo.getId()) .set(EdgStorageCageDetails::getTemperingLayoutId, swapGlassDetailInfo.getTemperingLayoutId()) .set(EdgStorageCageDetails::getTemperingFeedSequence, swapGlassDetailInfo.getTemperingFeedSequence()) ); edgStorageCageDetailsService.update(new LambdaUpdateWrapper<EdgStorageCageDetails>() .eq(EdgStorageCageDetails::getId, swapGlassDetailInfo.getId()) .set(EdgStorageCageDetails::getTemperingLayoutId, glassInfo.getTemperingLayoutId()) .set(EdgStorageCageDetails::getTemperingFeedSequence, glassInfo.getTemperingFeedSequence()) ); } } /** * 获取详情表内最大最小版图id的差值，判断是否出最小版图玻璃 * * @return */ public boolean queryMaxMinDiff(int threshold) { //获取笼子内最大版图id和最小版图id插值，判断是否大于阈值，大于阈值直接出最小版图玻璃 QueryWrapper<EdgStorageCageDetails> queryWrapper = new QueryWrapper<>(); queryWrapper.select("max(tempering_layout_id)-min(tempering_layout_id) as diff") .eq("state", Const.GLASS_STATE_IN) .inSql("slot", "select slot from edg_storage_cage where enable_state = " + Const.SLOT_ON); List<Object> list = edgStorageCageDetailsService.listObjs(queryWrapper); //获取笼内玻璃版图差值是否大于阈值 if (CollectionUtil.isNotEmpty(list)) { Long diff = (Long) list.get(0); return diff > threshold; } else { return Boolean.FALSE; } } public boolean saveHistoryTask(EdgStorageDeviceTask task) { EdgStorageDeviceTaskHistory taskHistory = new EdgStorageDeviceTaskHistory(); BeanUtils.copyProperties(task, taskHistory); taskHistory.setTaskType(task.getTaskRunning()); taskHistory.setCreateTime(new Date()); taskHistory.setTaskState(Const.RAW_GLASS_TASK_NEW); edgStorageDeviceTaskHistoryService.save(taskHistory); return Boolean.TRUE; } private boolean updateCellRemainWidth(int slot, int device) { List<EdgStorageCageDetails> list = edgStorageCageDetailsService.list(new LambdaQueryWrapper<EdgStorageCageDetails>().eq(EdgStorageCageDetails::getSlot, slot) .eq(EdgStorageCageDetails::getState, Const.GLASS_STATE_IN)); int remainWidth = cellLength; if (CollectionUtil.isNotEmpty(list)) { int widthTotal = (int) list.stream().map(e -> Math.max(e.getWidth(), e.getHeight()) + glassGap).mapToDouble(Double::intValue).sum(); remainWidth = cellLength - widthTotal >= 0 ? cellLength - widthTotal : 0; } edgStorageCageService.update(new LambdaUpdateWrapper<EdgStorageCage>(). set(EdgStorageCage::getRemainWidth, remainWidth).eq(EdgStorageCage::getSlot, slot).eq(EdgStorageCage::getDeviceId, device)); return Boolean.TRUE; } private ReadWriteEntity generateReadWriteEntity(String identifier, Object value) { return ReadWriteEntity.builder() .identifier(identifier) hangzhoumesParent/moduleService/CacheGlassModule/src/main/java/com/mes/job/opccallback/CacheGlassStartCallback.java
@@ -67,16 +67,7 @@ @Override public void onSubscribe(String identifier, Object value) { if (identifier.equals("PLC.WL2.plc_task_tate")) { startDate = new Date(); log.info("本次任务获取plc的值为{}，时间：{}，共耗时：{}ms", value, startDate); return; } if (!identifier.equals("PLC.WL2.plc_task_tate")) { Date endDate = new Date(); log.info("本次任务link后的值为{},时间：{}，共耗时：{}ms", value, endDate, endDate.getTime() - startDate.getTime()); startDate = null; } log.info("当前正在执行的任务为{}", value); String tableName = identifier.contains("edg_storage_device_one_task") ? EDG_STORAGE_DEVICE_ONE_TASK : EDG_STORAGE_DEVICE_TWO_TASK; int device = tableName.equals("edg_storage_device_one_task") ? 1 : 2; @@ -85,6 +76,10 @@ if (task == null) { log.info("任务表基础数据录入失败，请检查数据是否录入成功"); return; } if (task.getTaskState() == 2) { //防止出片任务且笼前有玻璃的情况，将进片id置空，即出片仅考虑笼内的玻璃 task.setGlassIdIn(""); } int request = Integer.parseInt("" + value); log.info("开始执行任务，任务请信息为{}", task); @@ -246,6 +241,8 @@ log.info("5、直通任务,将玻璃信息插入卧式理片笼,当前玻璃信息:{}", edgStorageCageDetails); //玻璃信息替换 String glassIdChange = queryAndChangeGlass(glassId); //处理在卧理内的玻璃信息：笼内的数据处理 queryEdgAndChangeGlass(edgStorageCageDetails.getGlassId(), glassIdChange); if (StringUtils.isNotBlank(glassIdChange)) { edgStorageCageDetails = new EdgStorageCageDetails(); GlassInfo one = glassInfoService.getOne(new LambdaQueryWrapper<GlassInfo>().eq(GlassInfo::getGlassId, glassId)); @@ -286,28 +283,24 @@ edgStorageCageDetailsService.update(wrapper); log.info("5、更新出片玻璃的状态为{}", Const.GLASS_STATE_OUT); } //玻璃信息替换 // String glassIdChange = queryAndChangeGlass(edgStorageCageDetails.getGlassId()); //处理在卧理内的玻璃信息：笼内的数据处理 // queryEdgAndChangeGlass(edgStorageCageDetails.getGlassId(), glassIdChange); //生成出片任务 task.setGlassIdOut(edgStorageCageDetails.getGlassId()); task.setStartCell(edgStorageCageDetails.getSlot()); task.setTaskRunning(taskType); // task.setWidth((int) edgStorageCageDetails.getWidth() * 10); // task.setHeight((int) edgStorageCageDetails.getHeight() * 10); // task.setThickness((int) edgStorageCageDetails.getThickness() * 10); // task.setFilmRemove(0); edgStorageDeviceTaskService.updateTaskMessage(tableName, task); saveHistoryTask(task); //更新详情表任务出片中 edgStorageCageDetailsService.update(new LambdaUpdateWrapper<EdgStorageCageDetails>() .set(EdgStorageCageDetails::getState, Const.GLASS_STATE_OUT) .eq(EdgStorageCageDetails::getGlassId, edgStorageCageDetails.getGlassId())); //todo:磨边对列表新增一条数据 //磨边对列表新增一条数据 EdgGlassTaskQueueInfo edgInfo = new EdgGlassTaskQueueInfo(); BeanUtils.copyProperties(task, edgInfo); edgInfo.setCreateTime(new Date()); edgInfo.setWidth((int) edgStorageCageDetails.getWidth()); edgInfo.setHeight((int) edgStorageCageDetails.getWidth()); edgInfo.setThickness((int) edgStorageCageDetails.getWidth()); edgInfo.setState(Const.GLASS_STATE_NEW); edgGlassTaskQueueInfoService.save(edgInfo); return Boolean.TRUE; hangzhoumesParent/moduleService/CacheGlassModule/src/main/resources/mapper/EdgStorageCageMapper.xml
@@ -16,7 +16,7 @@ left join edg_storage_cage_details t1 on t.slot = t1.slot where t.device_id = #{deviceId} and t1.state = 100 and t.remain_width >= #{width} and t.remain_width >= GREATEST(#{width}, #{height}) and t1.width = #{width} and t1.height = #{height} and t.enable_state = 1 hangzhoumesParent/moduleService/CacheVerticalGlassModule/src/main/java/com/mes/bigstorage/entity/dto/SlotSequenceDTO.java
@@ -19,6 +19,10 @@ */ private Integer temperingLayoutId; /** * 玻璃数量 */ private Integer glassCount; /** * 大理片详情中格子号 */ private Integer slot; hangzhoumesParent/moduleService/CacheVerticalGlassModule/src/main/java/com/mes/bigstorage/service/impl/BigStorageCageDetailsServiceImpl.java
@@ -283,7 +283,7 @@ .eq(BigStorageCageDetails::getLayer, glassInfo.getLayer()); // wrapper.eq(BigStorageCageDetails::getWidth, glassInfo.getWidth()).eq(BigStorageCageDetails::getHeight, glassInfo.getHeight()); } else { wrapper.eq(BigStorageCageDetails::getTemperingFeedSequence, glassInfo.getTemperingFeedSequence() + 1); wrapper.eq(BigStorageCageDetails::getTemperingFeedSequence, glassInfo.getTemperingFeedSequence() - 1); } BigStorageCage bigStorageCage = bigStorageCageService.selectJoinOne(BigStorageCage.class, wrapper); if (null != bigStorageCage) { @@ -312,17 +312,17 @@ //获取玻璃的厚度：重新选笼子需要按照笼子可放玻璃厚度进行选择 因为子查询排序对主sql无影响，所以先执行子查询获取顺序，然后一次去查询 List<Integer> deviceUsedList = bigStorageCageService.queryFreeDeviceByUsed(glassInfo.getThickness()); List<Integer> deviceUseds = bigStorageCageService.queryFreeDeviceByUsed(glassInfo.getThickness()); List<Integer> deviceUseds = bigStorageCageService.queryFreeDeviceByUsed(glassInfo.getThickness()); List<BigStorageCageDetails> engineerCount1 = baseMapper.selectList( new LambdaQueryWrapper<BigStorageCageDetails>() .notIn(BigStorageCageDetails::getState, Const.GLASS_STATE_OUT,Const.GLASS_STATE_DAMAGE,Const.GLASS_STATE_TAKE) .notIn(BigStorageCageDetails::getState, Const.GLASS_STATE_OUT, Const.GLASS_STATE_DAMAGE, Const.GLASS_STATE_TAKE) .select(BigStorageCageDetails::getEngineerId) .groupBy(BigStorageCageDetails::getEngineerId) .between(BigStorageCageDetails::getDeviceId, 1, 5) ); List<BigStorageCageDetails> engineerCount2 = baseMapper.selectList( new LambdaQueryWrapper<BigStorageCageDetails>() .notIn(BigStorageCageDetails::getState, Const.GLASS_STATE_OUT,Const.GLASS_STATE_DAMAGE,Const.GLASS_STATE_TAKE) .notIn(BigStorageCageDetails::getState, Const.GLASS_STATE_OUT, Const.GLASS_STATE_DAMAGE, Const.GLASS_STATE_TAKE) .select(BigStorageCageDetails::getEngineerId) .groupBy(BigStorageCageDetails::getEngineerId) .between(BigStorageCageDetails::getDeviceId, 6, 8) hangzhoumesParent/moduleService/CacheVerticalGlassModule/src/main/java/com/mes/bigstoragecagetask/entity/BigStorageCageHistoryTask.java
@@ -1,5 +1,7 @@ package com.mes.bigstoragecagetask.entity; import com.baomidou.mybatisplus.annotation.IdType; import com.baomidou.mybatisplus.annotation.TableId; import lombok.Data; import java.util.Date; @@ -13,6 +15,7 @@ @Data public class BigStorageCageHistoryTask { @TableId(value = "id", type = IdType.AUTO) private Integer id; /** * 玻璃id hangzhoumesParent/moduleService/CacheVerticalGlassModule/src/main/java/com/mes/bigstoragecagetask/entity/BigStorageCageTask.java
@@ -1,5 +1,6 @@ package com.mes.bigstoragecagetask.entity; import lombok.AllArgsConstructor; import lombok.Data; /** @@ -9,6 +10,7 @@ * @since 2024-11-08 21:40:17 */ @Data @AllArgsConstructor public class BigStorageCageTask { /** * 玻璃id hangzhoumesParent/moduleService/CacheVerticalGlassModule/src/main/java/com/mes/bigstoragecagetask/mapper/BigStorageCageTaskMapper.java
@@ -17,5 +17,8 @@ boolean updateTaskMessage(@Param("tableName") String tableName, @Param("task") BigStorageCageTask bigStorageCageInTask); int saveTaskMessage(@Param("tableName") String tableName, @Param("list") List<BigStorageCageTask> taskList); int removeAll(String tableName); }
@@ -17,5 +17,9 @@ List<BigStorageCageTask> queryTaskMessage(String tableName); boolean updateTaskMessage(@Param("tableName") String tableName, @Param("task") BigStorageCageTask bigStorageCageInTask); int saveTaskMessage(@Param("tableName") String tableName, List<BigStorageCageTask> taskList); int removeAll(@Param("tableName") String tableName); }
@@ -29,5 +29,15 @@ public boolean updateTaskMessage(String tableName, BigStorageCageTask bigStorageCageTask) { return bigStorageCageInTaskMapper.updateTaskMessage(tableName, bigStorageCageTask); } @Override public int saveTaskMessage(String tableName, List<BigStorageCageTask> taskList) { return bigStorageCageInTaskMapper.saveTaskMessage(tableName, taskList); } @Override public int removeAll(String tableName) { return bigStorageCageInTaskMapper.removeAll(tableName); } }
@@ -1,13 +1,19 @@ 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.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.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.bigstoragecagetask.entity.BigStorageCageHistoryTask; @@ -16,11 +22,16 @@ import com.mes.bigstoragecagetask.service.BigStorageCageTaskService; import com.mes.bigstoragetask.entity.UpdateBigStorageCageDTO; import com.mes.common.config.Const; import com.mes.damage.entity.Damage; import com.mes.damage.service.DamageService; import com.mes.glassinfo.entity.GlassInfo; import com.mes.glassinfo.service.GlassInfoService; import com.mes.temperingglass.service.TemperingGlassInfoService; import com.mes.temperingglass.entity.TemperingGlass; import com.mes.temperingglass.entity.TemperingGlassInfo; import com.mes.temperingglass.service.TemperingGlassService; 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.Value; @@ -40,10 +51,9 @@ @Resource private BigStorageCageDetailsService bigStorageCageDetailsService; @Resource private TemperingGlassInfoService temperingGlassInfoService; private TemperingGlassService temperingGlassService; @Resource private DamageService damageService; @Resource private GlassInfoService glassInfoService; @Resource @@ -56,22 +66,40 @@ @Autowired(required = false) MiloService miloService; @Resource private RedisUtil redisUtil; @Value("${mes.slotWidth}") private Integer slotWidth; @Value("${mes.glassGap}") private Integer glassGap; @Value("${mes.carWidth}") private Integer carWidth; @Value("${mes.outCarMaxSize}") private Integer outCarMaxSize; @Value("${mes.sequence.order}") private boolean sequenceOrder; @Scheduled(fixedDelay = 1000) public void inBigStorageTask() throws Exception { ReadWriteEntity inkageEntity = miloService.readFromOpcUa("PLC.DPL1.inkageState"); if (!"1".equals(inkageEntity.getValue())) { ReadWriteEntity inkageEntity = miloService.readFromOpcUa("DLP1A.DLP1A.mesControl"); if (true != Boolean.parseBoolean(inkageEntity.getValue() + "")) { log.info("当前为非联机状态，结束进片任务"); return; } ReadWriteEntity requestEntity = miloService.readFromOpcUa("PLC.DPL1.plcInGlassRequest"); if (!"1".equals(requestEntity.getValue())) { ReadWriteEntity requestEntity = miloService.readFromOpcUa("DLP1A.DLP1A.RequestMes"); if (!"1".equals(requestEntity.getValue() + "")) { log.info("当前未收到进片请求，结束进片任务"); return; } ReadWriteEntity mesReplyEntity = miloService.readFromOpcUa("DLP1A.DLP1A.MesReply"); if ("1".equals(mesReplyEntity.getValue() + "")) { log.info("有正在执行的任务，结束进片任务"); return; } //获取进片任务表 @@ -81,18 +109,19 @@ } List<String> glassIdList = inTaskList.stream().map(BigStorageCageTask::getGlassId).collect(Collectors.toList()); log.info("获取任务的玻璃id：{}", glassIdList); Map<String, List<BigStorageCageTask>> taskMap = inTaskList.stream().collect(Collectors.groupingBy(BigStorageCageTask::getGlassId)); List<GlassInfo> glassInfoList = glassInfoService.list(new LambdaQueryWrapper<GlassInfo>().in(GlassInfo::getGlassId, glassIdList)); Map<String, List<GlassInfo>> glassListMap = glassInfoList.stream().collect(Collectors.groupingBy(GlassInfo::getGlassId)); //计算目标格子 List<BigStorageCageHistoryTask> historyTasks = new ArrayList<>(); for (GlassInfo info : glassInfoList) { for (BigStorageCageTask task : inTaskList) { GlassInfo info = glassListMap.get(task.getGlassId()).get(0); //获取目标格子信息 BigStorageDTO bigStorageDTO = bigStorageCageDetailsService.queryTargetSlotByTempering(info); // 临时更新格子的剩余尺寸：防止相邻玻璃进同一格子造成剩余尺寸不足，玻璃越界的情况，任务完成后再次更新大理片笼表剩余宽度（按照笼内玻璃数量更新大理片笼剩余尺寸） bigStorageCageService.update(new LambdaUpdateWrapper<BigStorageCage>() .set(BigStorageCage::getRemainWidth, bigStorageDTO.getWidth() - Math.max(info.getWidth(), info.getHeight()) - glassGap) .eq(BigStorageCage::getSlot, bigStorageDTO.getSlot())); BigStorageCageTask task = taskMap.get(info.getGlassId()).get(0); task.setTargetSlot(bigStorageDTO.getSlot()); task.setGlassId(info.getGlassId()); bigStorageCageTaskService.updateTaskMessage("big_storage_cage_in_one_task", task); @@ -102,25 +131,132 @@ 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.setGap(glassGap); cageDetails.setId(null); bigStorageCageDetailsService.save(cageDetails); } //历史数据入库 bigStorageCageHistoryTaskService.saveBatch(historyTasks); //向opc发送启动信号 miloService.writeToOpcWord(generateReadWriteEntity("PLC.DPL1.taskRunning", 1)); miloService.writeToOpcWord(generateReadWriteEntity("DLP1A.DLP1A.MesReply", 1)); } @Scheduled(fixedDelay = 1000) public void finishBigStorageTask() throws Exception { ReadWriteEntity inkageEntity = miloService.readFromOpcUa("PLC.DPL1.inkageState"); if (!"1".equals(inkageEntity.getValue())) { public void outBigStorageTask() throws Exception { Date startDate = new Date(); ReadWriteEntity inkageEntity = miloService.readFromOpcUa("DLP1B.DLP1B.mesControl"); if (true != Boolean.parseBoolean(inkageEntity.getValue() + "")) { log.info("当前为非联机状态，结束进片任务"); return; } ReadWriteEntity requestEntity = miloService.readFromOpcUa("DLP1B.DLP1B.RequestMes"); if (!"1".equals(requestEntity.getValue() + "")) { log.info("当前未收到出片请求，结束出片任务"); return; } //获取出片任务表 List<BigStorageCageTask> outTaskList = bigStorageCageTaskService.queryTaskMessage("big_storage_cage_out_one_task"); if (CollectionUtils.isNotEmpty(outTaskList)) { log.info("有正在执行的出片任务，结束本次出片任务"); return; } //todo:是否允许钢化 if (redisUtil.getCacheObject("temperingSwitch")) { //是否有正在钢化的玻璃:钢化小片表关联历史任务表，筛选未出笼的玻璃信息 List<TemperingGlass> temperingGlassList = temperingGlassService.selectJoinList(TemperingGlass.class, new MPJLambdaWrapper<TemperingGlass>() .selectAll(TemperingGlass.class) .leftJoin(BigStorageCageHistoryTask.class, BigStorageCageHistoryTask::getGlassId, TemperingGlass::getGlassId) .eq(TemperingGlass::getState, Const.TEMPERING_NEW) .eq(BigStorageCageHistoryTask::getTaskType, Const.BIG_STORAGE_BEFORE_OUT) .isNull(BigStorageCageHistoryTask::getGlassId) .orderBy(Boolean.TRUE, sequenceOrder, TemperingGlass::getTemperingFeedSequence)); //todo:历史任务表 if (CollectionUtils.isNotEmpty(temperingGlassList)) { log.info("有正在出片的钢化任务"); computeOutGlassInfo(temperingGlassList, "big_storage_cage_out_one_task", Const.TEMPERING_OUT_TARGET_POSITION, Const.GLASS_STATE_OUT_ING, Const.BIG_STORAGE_BEFORE_OUT); Date endDate = new Date(); log.info("大理片笼出片任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime()); return; } //钢化优先：获取理片笼 玻璃小片 破损表 数量 判断笼内版图是否到齐 List<TemperingLayoutDTO> temperingLayoutDTOList = bigStorageCageDetailsService.temperingIsAll(); if (CollectionUtils.isNotEmpty(temperingLayoutDTOList)) { //玻璃到齐包括已出片的 //到齐，将玻璃小片数据存入钢化小片表，逻辑生成出片任务 结束 for (TemperingLayoutDTO item : temperingLayoutDTOList) { // if (item.getEngineerId().equals(redisUtil.getCacheObject("temperingengineerId"))) { List<TemperingGlass> temperingGlassInfos = glassInfoService.selectJoinList(TemperingGlass.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)) { temperingGlassService.saveBatch(temperingGlassInfos); computeOutGlassInfo(temperingGlassInfos, "big_storage_cage_out_one_task", Const.TEMPERING_OUT_TARGET_POSITION, Const.GLASS_STATE_OUT_ING, Const.BIG_STORAGE_BEFORE_OUT); Date endDate = new Date(); log.info("大理片笼出片任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime()); return; } // } } } } //是否有人工下片任务 有直接出 List<BigStorageCageDetails> artificialList = bigStorageCageDetailsService.list(new LambdaQueryWrapper<BigStorageCageDetails>() .eq(BigStorageCageDetails::getState, Const.GLASS_STATE_ARTIFICIAL) .orderByAsc(BigStorageCageDetails::getSlot) .orderByDesc(BigStorageCageDetails::getId)); if (CollectionUtils.isNotEmpty(artificialList)) { computeOutGlassInfo(artificialList, "big_storage_cage_out_one_task", Const.ARTIFICIAL_OUT_TARGET_POSITION, Const.GLASS_STATE_OUT_ING, Const.BIG_STORAGE_BEFORE_OUT); Date endDate = new Date(); log.info("大理片笼出片任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime()); return; } //是否存在需要内部调度的格子:执行内部调度任务 List<TemperingLayoutDTO> temperingOccupySlotList = bigStorageCageDetailsService.queryTemperingOccupySlot(); if (CollectionUtils.isNotEmpty(temperingOccupySlotList)) { loop: for (TemperingLayoutDTO temperingOccupySlot : temperingOccupySlotList) { List<SlotSequenceDTO> 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; int totalCount = first.getGlassCount() + second.getGlassCount(); if (totalCount <= 6 && first.getMinSequence() == second.getMaxSequence() + 1 && second.getRemainWidth() > slotWidth && slotWidth >= 0) { List<BigStorageCageDetails> list = bigStorageCageDetailsService.list(new LambdaQueryWrapper<BigStorageCageDetails>() .eq(BigStorageCageDetails::getSlot, first.getSlot()).eq(BigStorageCageDetails::getState, Const.GLASS_STATE_IN) .orderBy(Boolean.TRUE, sequenceOrder, BigStorageCageDetails::getTemperingFeedSequence)); if (CollectionUtils.isNotEmpty(list)) { computeOutGlassInfo(list, "big_storage_cage_out_one_task", second.getSlot(), Const.GLASS_STATE_SCHEDULE_ING, Const.BIG_STORAGE_BEFORE_DISPATCH); } updateSlotRemainBySlots(Arrays.asList(second.getSlot())); break loop; } } } } Date endDate = new Date(); log.info("大理片笼出片任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime()); return; } @Scheduled(fixedDelay = 1000) public void finishInBigStorageTask() throws Exception { ReadWriteEntity inkageEntity = miloService.readFromOpcUa("DLP1A.DLP1A.mesControl"); if (true != Boolean.parseBoolean(inkageEntity.getValue() + "")) { log.info("当前为非联机状态，结束完成进片任务"); return; } @@ -128,16 +264,17 @@ List<BigStorageCageTask> inTaskList = bigStorageCageTaskService.queryTaskMessage("big_storage_cage_in_one_task"); if (CollectionUtils.isEmpty(inTaskList)) { log.info("当前大车无进片玻璃，结束完成进片任务"); return; } List<BigStorageCageTask> unFinishTaskList = inTaskList.stream().filter(e -> e.getTaskState() <= 1).collect(Collectors.toList()); List<BigStorageCageTask> unFinishTaskList = inTaskList.stream().filter(e -> e.getTaskState() <= 1 || e.getStartSlot() == 0).collect(Collectors.toList()); if (CollectionUtils.isNotEmpty(unFinishTaskList)) { log.info("存在未完成的玻璃信息,玻璃：{}", unFinishTaskList); return; } Map<Integer, List<BigStorageCageTask>> taskMap = inTaskList.stream().collect(Collectors.groupingBy(BigStorageCageTask::getTaskState)); //按照任务状态修改大理片笼内的玻璃数据 // 重新计算大理片笼内的剩余尺寸 taskMap.forEach((e1, v) -> { List<String> glassList = v.stream().map(BigStorageCageTask::getGlassId).collect(Collectors.toList()); if (e1 == 2) { //进片完成 log.info("3、获取进片已完成的玻璃信息id:{}", v); @@ -152,165 +289,247 @@ updateSlotRemainBySlots(inSuccessGlassSlot); } else if (e1 == 3) { //破损处理 dealDamageInTask(v); } else { //清空理片笼空数据 noDealInTask(v); } }); //todo:按照任务状态修改大理片笼内的玻璃数据 //todo:重新计算大理片笼内的剩余尺寸 //todo:更新历史任务表中的任务状态 //todo:清空任务表数据 //todo:清空启动状态 for (BigStorageCageTask item : inTaskList) { //更新历史任务表中的任务状态 bigStorageCageHistoryTaskService.update(new LambdaUpdateWrapper<BigStorageCageHistoryTask>() .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发送启动信号 miloService.writeToOpcWord(generateReadWriteEntity("DLP1A.DLP1A.MesReply", 0)); } // // @Scheduled(fixedDelay = 300) // public void updateOutGlassStateTask() { // Date startDate = new Date(); // log.info("1、大理片笼出片完成后更新大理片笼数据任务开始执行时间：{}", startDate); // //因为大理片笼和出片任务是两个库的数据，所以要分开查找 // List<Object> list = bigStorageCageDetailsService.listObjs(new LambdaQueryWrapper<BigStorageCageDetails>() // .select(BigStorageCageDetails::getGlassId).eq(BigStorageCageDetails::getState, Const.GLASS_STATE_OUT_ING)); // if (CollectionUtils.isNotEmpty(list)) { // log.info("2、获取所有正在出片的玻璃信息id:{}", list); // List<String> glassIds = list.stream().map(String::valueOf).collect(Collectors.toList()); // List<BigStorageCageOutTask> outSuccessGlass = bigStorageCageOutTaskService.list(new LambdaQueryWrapper<BigStorageCageOutTask>() // .in(BigStorageCageOutTask::getGlassId, glassIds).in(BigStorageCageOutTask::getTaskState, Const.BIG_STORAGE_OUT_ALL)); // if (CollectionUtils.isNotEmpty(outSuccessGlass)) { // for (BigStorageCageOutTask bigStorageCageOutTask : outSuccessGlass // ) { // if (bigStorageCageOutTask.getEndSlot().equals(Const.ARTIFICIAL_OUT_TARGET_POSITION)) { // temperingGlassInfoService.update( // new LambdaUpdateWrapper<TemperingGlassInfo>() // .set(TemperingGlassInfo::getState, Const.TEMPERING_END) // .eq(TemperingGlassInfo::getGlassId, bigStorageCageOutTask.getGlassId()) // ); // } // } // log.info("3、获取出片已完成的玻璃信息id:{}", outSuccessGlass); // List<UpdateBigStorageCageDTO> 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<Integer> outSuccessSlotList = outSuccessGlass.stream().map(BigStorageCageOutTask::getStartSlot).collect(Collectors.toList()); // log.info("4、大理片笼出片状态已完成已完成的玻璃信息id:{}", outSuccessGlass); // //更新理片笼玻璃尺寸 // baseService.updateSlotRemainBySlots(outSuccessSlotList); // log.info("5、大理片笼进片目标格子尺寸更新完成"); // } @Scheduled(fixedDelay = 1000) public void finishOutBigStorageTask() throws Exception { // ReadWriteEntity inkageEntity = miloService.readFromOpcUa("DLP1B.DLP1B.mesControl"); // if (true != Boolean.parseBoolean(inkageEntity.getValue() + "")) { // log.info("当前为非联机状态，结束完成出片任务"); // return; // } // 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<Object> list = bigStorageCageDetailsService.listObjs(new LambdaQueryWrapper<BigStorageCageDetails>() // .select(BigStorageCageDetails::getGlassId).eq(BigStorageCageDetails::getState, Const.GLASS_STATE_SCHEDULE_ING)); // if (CollectionUtils.isNotEmpty(list)) { // log.info("2、获取所有正在出片的玻璃信息id:{}", list); // List<String> glassIds = list.stream().map(String::valueOf).collect(Collectors.toList()); // List<BigStorageCageOutTask> scheduleSuccessGlass = bigStorageCageOutTaskService.list(new LambdaQueryWrapper<BigStorageCageOutTask>() // .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<UpdateBigStorageCageDTO> 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<String> scheduleSuccessGlassIds = scheduleSuccessGlass.stream().map(BigStorageCageOutTask::getGlassId).collect(Collectors.toList()); // log.info("4、大理片笼出片状态已完成已完成的玻璃信息id:{}", scheduleSuccessGlassIds); // //更新理片笼玻璃尺寸 // List<Integer> slotList = scheduleSuccessGlass.stream().map(BigStorageCageOutTask::getStartSlot).distinct().collect(Collectors.toList()); // slotList.addAll(scheduleSuccessGlass.stream().map(BigStorageCageOutTask::getEndSlot).distinct().collect(Collectors.toList())); // baseService.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<BigStorageCageFeedTask> inDamageTaskInfoList = bigStorageCageFeedTaskService.list(new LambdaQueryWrapper<BigStorageCageFeedTask>() // .in(BigStorageCageFeedTask::getTaskState, Const.GLASS_STATE_DAMAGE_TAKE)); // if (CollectionUtils.isNotEmpty(inDamageTaskInfoList)) { // log.info("获取进片任务表中破损的玻璃信息{}", inDamageTaskInfoList); // bigStorageCageFeedTaskService.remove(new LambdaQueryWrapper<BigStorageCageFeedTask>().in(BigStorageCageFeedTask::getTaskState, Const.GLASS_STATE_DAMAGE_TAKE)); // //理片笼详情表数据状态更新 // bigStorageCageDetailsService.remove(new LambdaQueryWrapper<BigStorageCageDetails>() // .eq(BigStorageCageDetails::getState, Const.GLASS_STATE_NEW).in(BigStorageCageDetails::getGlassId, inDamageTaskInfoList.stream().map(BigStorageCageFeedTask::getGlassId).collect(Collectors.toList()))); // //将破损信息新增入破损表 // List<Integer> slotList = new ArrayList<>(); // for (BigStorageCageFeedTask bigStorageCageFeedTask : inDamageTaskInfoList) { // Damage damage = new Damage(); // damage.setGlassId(bigStorageCageFeedTask.getGlassId()); // damage.setLine(bigStorageCageFeedTask.getLine()); // damage.setWorkingProcedure("磨边"); // damage.setRemark("进笼前卧转立"); // damage.setStatus(1); // damage.setType(bigStorageCageFeedTask.getTaskState()); // damageService.insertDamage(damage); // slotList.add(bigStorageCageFeedTask.getTargetSlot()); // } // //更新格子剩余宽度 // baseService.updateSlotRemainBySlots(slotList); // log.info("进片任务执行完成"); // } // //获取出片任务表中状态为破损的数据 // List<BigStorageCageOutTask> outDamageTaskInfoList = bigStorageCageOutTaskService.list(new LambdaQueryWrapper<BigStorageCageOutTask>() // .in(BigStorageCageOutTask::getTaskState, Const.GLASS_STATE_DAMAGE_TAKE)); // if (CollectionUtils.isNotEmpty(outDamageTaskInfoList)) { // log.info("获取出片任务表中破损的玻璃信息{}", outDamageTaskInfoList); // bigStorageCageOutTaskService.remove(new LambdaQueryWrapper<BigStorageCageOutTask>().in(BigStorageCageOutTask::getTaskState, Const.GLASS_STATE_DAMAGE_TAKE)); // List<String> glassIdList = outDamageTaskInfoList.stream().map(BigStorageCageOutTask::getGlassId).collect(Collectors.toList()); // //移除钢化下片表数据 // temperingGlassInfoService.remove(new LambdaQueryWrapper<TemperingGlassInfo>().in(TemperingGlassInfo::getGlassId, glassIdList)); // //理片笼详情表数据状态删除 // bigStorageCageDetailsService.remove(new LambdaQueryWrapper<BigStorageCageDetails>().in(BigStorageCageDetails::getGlassId, glassIdList)); // //将破损信息新增入破损表 // List<Integer> slotList = new ArrayList<>(); // for (BigStorageCageOutTask bigStorageCageOutTask : outDamageTaskInfoList) { // Damage damage = new Damage(); // damage.setGlassId(bigStorageCageOutTask.getGlassId()); // damage.setLine(bigStorageCageOutTask.getEndSlot()); // damage.setWorkingProcedure("钢化"); // damage.setRemark("出片后卧转立"); // damage.setStatus(1); // damage.setType(bigStorageCageOutTask.getTaskState()); // damageService.insertDamage(damage); // slotList.add(bigStorageCageOutTask.getStartSlot()); // } // //更新格子剩余宽度 // baseService.updateSlotRemainBySlots(slotList); // log.info("出片任务执行完成"); // } // Date endDate = new Date(); // log.info("大理片笼破损玻璃清除任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime()); // return; // } //获取进片任务表 List<BigStorageCageTask> outTaskList = bigStorageCageTaskService.queryTaskMessage("big_storage_cage_out_one_task"); if (CollectionUtils.isEmpty(outTaskList)) { log.info("当前大车无进片玻璃，结束完成进片任务"); return; } List<BigStorageCageTask> unFinishTaskList = outTaskList.stream().filter(e -> e.getTaskState() <= 1 || e.getStartSlot() == 0).collect(Collectors.toList()); if (CollectionUtils.isNotEmpty(unFinishTaskList)) { log.info("存在未完成的玻璃信息,玻璃：{}", unFinishTaskList); return; } Map<Integer, List<BigStorageCageTask>> 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<Integer> outSuccessGlassSlot = new ArrayList<>(); if (finalTaskType.equals(Const.BIG_STORAGE_BEFORE_OUT)) { outSuccessGlassSlot = v.stream().map(BigStorageCageTask::getStartSlot).collect(Collectors.toList()); } else { outSuccessGlassSlot = v.stream().map(BigStorageCageTask::getTargetSlot).collect(Collectors.toList()); } List<UpdateBigStorageCageDTO> 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()); bigStorageCageDetailsService.updateBySlot(storageCageDTOList, finalTaskType); log.info("4、大理片笼进片状态已完成已完成的玻璃信息id:{}", v); updateSlotRemainBySlots(outSuccessGlassSlot); } else if (e1 == 3) { //破损处理 dealDamageOutTask(v); } else { //清空理片笼空数据 noDealOutTask(v); } }); for (BigStorageCageTask item : outTaskList) { //更新历史任务表中的任务状态 bigStorageCageHistoryTaskService.update(new LambdaUpdateWrapper<BigStorageCageHistoryTask>() .set(BigStorageCageHistoryTask::getTaskState, item.getTaskState()) .eq(BigStorageCageHistoryTask::getTaskType, taskType) .eq(BigStorageCageHistoryTask::getGlassId, item.getGlassId())); } //清空任务表数据 bigStorageCageTaskService.removeAll("big_storage_cage_out_one_task"); //清空启动状态 //向opc发送启动信号 miloService.writeToOpcWord(generateReadWriteEntity("DLP1B.DLP1B.MesReply", 0)); } private void dealDamageInTask(List<BigStorageCageTask> damageTaskList) { // 获取进片任务表中状态为破损的数据 log.info("破损的玻璃信息有：{}", damageTaskList); //移除理片笼详情表任务执行过程中破损的玻璃 bigStorageCageDetailsService.remove(new LambdaQueryWrapper<BigStorageCageDetails>() .eq(BigStorageCageDetails::getState, Const.GLASS_STATE_NEW) .in(BigStorageCageDetails::getGlassId, damageTaskList.stream().map(BigStorageCageTask::getGlassId).collect(Collectors.toList()))); //将破损信息新增入破损表 List<Integer> 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<BigStorageCageTask> damageTaskList) { // 获取进片任务表中状态为破损的数据 log.info("破损的玻璃信息有：{}", damageTaskList); //移除理片笼详情表任务执行过程中破损的玻璃 bigStorageCageDetailsService.remove(new LambdaQueryWrapper<BigStorageCageDetails>() .in(BigStorageCageDetails::getState, Const.GLASS_STATE_IN_ALL_ZERO) .in(BigStorageCageDetails::getGlassId, damageTaskList.stream().map(BigStorageCageTask::getGlassId).collect(Collectors.toList()))); //将破损信息新增入破损表 List<Integer> 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<BigStorageCageTask> noDealTaskList) { // 获取进片任务表中状态为破损的数据 log.info("破损的玻璃信息有：{}", noDealTaskList); //移除理片笼详情表未执行任务的空记录信息 bigStorageCageDetailsService.remove(new LambdaQueryWrapper<BigStorageCageDetails>() .eq(BigStorageCageDetails::getState, Const.GLASS_STATE_NEW) .in(BigStorageCageDetails::getGlassId, noDealTaskList.stream().map(BigStorageCageTask::getGlassId).collect(Collectors.toList()))); //记录格子号，按格子号更新剩余尺寸 List<Integer> slotList = new ArrayList<>(); for (BigStorageCageTask item : noDealTaskList) { slotList.add(item.getTargetSlot()); slotList.add(item.getStartSlot()); } //更新格子剩余宽度 updateSlotRemainBySlots(slotList); log.info("进片任务-无动作执行完成"); } private void noDealOutTask(List<BigStorageCageTask> noDealTaskList) { // 获取进片任务表中状态为破损的数据 log.info("破损的玻璃信息有：{}", noDealTaskList); if (Const.OUT_TARGET_POSITION_ALL.contains(noDealTaskList.get(0).getTargetSlot())) { //出片任务:将出片中状态恢复为在笼内 List<String> glassList = noDealTaskList.stream().map(BigStorageCageTask::getGlassId).collect(Collectors.toList()); bigStorageCageDetailsService.update(new LambdaUpdateWrapper<BigStorageCageDetails>() .set(BigStorageCageDetails::getState, Const.GLASS_STATE_IN) .in(BigStorageCageDetails::getGlassId, glassList)); } else { //调度任务：将调度中状态改为在笼内，格子号恢复为调度前的格子 for (BigStorageCageTask item : noDealTaskList) { bigStorageCageDetailsService.update(new LambdaUpdateWrapper<BigStorageCageDetails>() .set(BigStorageCageDetails::getSlot, item.getStartSlot()) .set(BigStorageCageDetails::getState, Const.GLASS_STATE_IN) .eq(BigStorageCageDetails::getGlassId, item.getGlassId())); } } //将破损信息新增入破损表 List<Integer> slotList = new ArrayList<>(); for (BigStorageCageTask item : noDealTaskList) { slotList.add(item.getTargetSlot()); slotList.add(item.getStartSlot()); } //更新格子剩余宽度 updateSlotRemainBySlots(slotList); log.info("出片任务-无动作执行完成"); } /** * 出片一次仅生成一车玻璃 * * @param list * @param <T> * @return */ private <T extends BigStorageCageBaseInfo> Boolean computeOutGlassInfo(List<T> list, String tableName, int targetSlot, int state, int taskType) { //任务数据:获取车子存放玻璃最大数量,玻璃间隔 List<BigStorageCageTask> bigStorageCageTaskList = new ArrayList<>(); //打车剩余尺寸 Integer remainWidth = carWidth; 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(CollectionUtils.isEmpty(bigStorageCageTaskList), "未获取出片数据，结束出片任务"); log.info("获取出片任务数据{}条，执行保存", bigStorageCageTaskList.size()); List<String> 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.saveTaskMessage(tableName, bigStorageCageTaskList); List<BigStorageCageHistoryTask> 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<BigStorageCageDetails>() .set(BigStorageCageDetails::getState, state) .set(Const.GLASS_STATE_SCHEDULE_ING.equals(state), BigStorageCageBaseInfo::getSlot, targetSlot) .in(BigStorageCageDetails::getGlassId, glassIds)); return Boolean.TRUE; } public void updateSlotRemainBySlots(List<Integer> slotList) { //获取格子内所有的玻璃信息 hangzhoumesParent/moduleService/CacheVerticalGlassModule/src/main/resources/mapper/BigStorageCageDetailsMapper.xml
@@ -13,6 +13,7 @@ <result column="engineer_id" property="engineerId"/> <result column="tempering_layout_id" property="temperingLayoutId"/> <result column="slot" property="slot"/> <result column="glass_count" property="glassCount"/> <result column="max_sequence" property="maxSequence"/> <result column="min_sequence" property="minSequence"/> <result column="remain_width" property="remainWidth"/> @@ -65,6 +66,7 @@ SELECT ENGINEER_ID, TEMPERING_LAYOUT_ID, SLOT, count(*) as glass_count, MAX(TEMPERING_FEED_SEQUENCE) AS MAX_SEQUENCE, MIN(TEMPERING_FEED_SEQUENCE) AS MIN_SEQUENCE FROM BIG_STORAGE_CAGE_DETAILS hangzhoumesParent/moduleService/CacheVerticalGlassModule/src/main/resources/mapper/BigStorageCageInTaskMapper.xml
@@ -8,18 +8,29 @@ <result column="target_slot" property="targetSlot"/> <result column="task_state" property="taskState"/> </resultMap> <insert id="saveTaskMessage"> INSERT INTO ${tableName} (glass_id, start_slot, target_slot,task_state) VALUES <foreach collection="list" item="item" index="index" separator=","> (#{item.glassId}, #{item.startSlot},#{item.targetSlot},#{item.taskState}) </foreach> </insert> <delete id="removeAll"> delete from ${tableName} </delete> <select id="queryTaskMessage" resultMap="baseMap"> select * from ${tableName} where glass_id is not null or glass_id != '' and glass_id != '' </select> <update id="updateTaskMessage"> UPDATE ${tableName} SET start_slot = #{task.startSlot} SET target_slot = #{task.targetSlot} where glass_id = #{task.glassId} </update>
@@ -2,7 +2,7 @@ port: 8083 spring: profiles: active: dev active: yw application: name: loadGlass liquibase: @@ -13,4 +13,11 @@ log-impl: org.apache.ibatis.logging.stdout.StdOutImpl kangaroohy: milo: enabled: false enabled: false primary: default config: default: endpoint: opc.tcp://192.168.0.39:49320 security-policy: basic256sha256 username: admin password: 1qaz2wsx3edc4rfv
