hangzhoumesParent/common/servicebase/src/main/java/com/mes/common/config/Const.java
@@ -236,5 +236,13 @@ */ public static final List<Integer> RAW_GLASS_DEVICE = Arrays.asList(1, 2, 3); /** * 原片上片状态 * 0 新增 * 100 已完成 */ public static final Integer LOAD_RAW_GLASS_NEW = 0; public static final Integer LOAD_RAW_GLASS_SUCCESS = 100; } hangzhoumesParent/moduleService/CacheGlassModule/src/main/java/com/mes/edgglasstaskqueueinfo/entity/EdgGlassTaskQueueInfo.java
New file @@ -0,0 +1,51 @@ package com.mes.edgglasstaskqueueinfo.entity; import lombok.Data; import java.util.Date; /** * (EdgGlassTaskQueueInfo)表实体类 * * @author makejava * @since 2024-11-03 15:42:12 */ @SuppressWarnings("serial") @Data public class EdgGlassTaskQueueInfo { /** * 磨边前玻璃id */ private String glassId; /** * 宽 */ private Integer width; /** * 高 */ private Integer height; /** * 厚 */ private Integer thickness; /** * 状态 */ private Integer state; /** * 线路 */ private Integer line; /** * 创建时间 */ private Date createTime; /** * 更新时间 */ private Date updateTime; }
New file @@ -0,0 +1,15 @@ package com.mes.edgglasstaskqueueinfo.mapper; import com.baomidou.mybatisplus.core.mapper.BaseMapper; import com.mes.edgglasstaskqueueinfo.entity.EdgGlassTaskQueueInfo; /** * (EdgGlassTaskQueueInfo)表数据库访问层 * * @author makejava * @since 2024-11-03 15:42:11 */ public interface EdgGlassTaskQueueInfoDao extends BaseMapper<EdgGlassTaskQueueInfo> { }
New file @@ -0,0 +1,15 @@ package com.mes.edgglasstaskqueueinfo.service; import com.baomidou.mybatisplus.extension.service.IService; import com.mes.edgglasstaskqueueinfo.entity.EdgGlassTaskQueueInfo; /** * (EdgGlassTaskQueueInfo)表服务接口 * * @author makejava * @since 2024-11-03 15:42:16 */ public interface EdgGlassTaskQueueInfoService extends IService<EdgGlassTaskQueueInfo> { }
New file @@ -0,0 +1,19 @@ package com.mes.edgglasstaskqueueinfo.service.impl; import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl; import com.mes.edgglasstaskqueueinfo.entity.EdgGlassTaskQueueInfo; import com.mes.edgglasstaskqueueinfo.mapper.EdgGlassTaskQueueInfoDao; import com.mes.edgglasstaskqueueinfo.service.EdgGlassTaskQueueInfoService; import org.springframework.stereotype.Service; /** * (EdgGlassTaskQueueInfo)表服务实现类 * * @author makejava * @since 2024-11-03 15:42:19 */ @Service public class EdgGlassTaskQueueInfoServiceImpl extends ServiceImpl<EdgGlassTaskQueueInfoDao, EdgGlassTaskQueueInfo> implements EdgGlassTaskQueueInfoService { }
@@ -1,14 +1,23 @@ package com.mes.job; import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; 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.opctask.entity.EdgStorageDeviceTask; import com.mes.opctask.service.EdgStorageDeviceTaskService; import lombok.extern.slf4j.Slf4j; import org.apache.commons.lang.StringUtils; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.scheduling.annotation.Scheduled; import org.springframework.stereotype.Component; import javax.annotation.Resource; import java.util.Arrays; import java.util.ArrayList; import java.util.List; /** * @Author : zhoush @@ -19,16 +28,98 @@ @Slf4j public class OpcCacheGlassTask { private static final String EDG_STORAGE_DEVICE_ONE_TASK = "edg_storage_device_one_task"; private static final String EDG_STORAGE_DEVICE_TWO_TASK = "edg_storage_device_two_task"; @Autowired(required = false) MiloService miloService; @Resource(name = "cacheGlassStartCallback") SubscriptionCallback cacheGlassStartCallback; @Scheduled(fixedDelay = Long.MAX_VALUE) @Resource(name = "cacheGlassTestCallback") SubscriptionCallback cacheGlassTestCallback; @Resource EdgStorageDeviceTaskService edgStorageDeviceTaskService; @Resource EdgGlassTaskQueueInfoService edgGlassTaskQueueInfoService; private int sum = 0; @Scheduled(fixedDelay = 10) public void startOpcTask() throws Exception { // miloService.subscriptionFromOpcUa(Arrays.asList("C101-WL.S7-1200.plc_task_state", "D101-WL.S7-1200.plc_task_state"), cacheGlassStartCallback); miloService.subscriptionFromOpcUa(Arrays.asList("mes.dec.edg_storage_device_one_task[1].task_state", "D101-WL.S7-1200.plc_task_state"), cacheGlassStartCallback); log.info("--------------------s---------------------------"); // miloService.subscriptionFromOpcUa(Arrays.asList("mes.dec.edg_storage_device_one_task[1].task_state", "D101-WL.S7-1200.plc_task_state"), cacheGlassTestCallback); // log.info("--------------------s---------------------------"); EdgStorageDeviceTask task = edgStorageDeviceTaskService.queryTaskMessage("edg_storage_device_one_task"); try { if (task == null) { log.info("任务表基础数据录入失败，请检查数据是否录入成功"); return; } if (task.getTaskState() == sum) { return; } sum = task.getTaskState(); task.setTaskRunning(sum); log.info("当前第{}次执行", task.getTaskRunning()); // task.setTaskState(task.getTaskRunning()); edgStorageDeviceTaskService.updateTaskMessage("edg_storage_device_one_task", task); } catch (Exception e) { log.info("{}", e.getMessage()); } } // mesControlWord glassId // width height // thickness filmRemove // deviceControlWord deviceWarnState // @Scheduled(fixedDelay = 1000) public void edgOpcTask() throws Exception { ReadWriteEntity controlEntity = miloService.readFromOpcUa("A001-MB1.dev.deviceControlWord"); String deviceControlWord = (String) controlEntity.getValue(); if ("0".equals(deviceControlWord)) { ReadWriteEntity messageEntity = miloService.readFromOpcUa("A001-MB1.dev.mesControlWord"); String messageValue = (String) messageEntity.getValue(); if ("1".equals(messageValue)) { List<ReadWriteEntity> list = new ArrayList<>(); list.add(generateReadWriteEntity("A001-MB1.dev.mesControlWord", 0)); miloService.writeToOpcWord(list); } log.info("当前未收到磨边机的请求任务"); return; } EdgStorageDeviceTask task = edgStorageDeviceTaskService.queryTaskMessage(EDG_STORAGE_DEVICE_ONE_TASK); String glassId = task.getGlassId(); if (StringUtils.isBlank(glassId)) { log.info("磨边前的架子没有玻璃信息"); return; } //获取磨边对列 EdgGlassTaskQueueInfo edgInfo = edgGlassTaskQueueInfoService.getOne(new LambdaQueryWrapper<EdgGlassTaskQueueInfo>() .eq(EdgGlassTaskQueueInfo::getGlassId, glassId) .eq(EdgGlassTaskQueueInfo::getState, Const.GLASS_STATE_NEW)); if (edgInfo == null) { log.info("对列表中的玻璃id错误，请检查数据，玻璃id：{}", glassId); return; } List<ReadWriteEntity> list = new ArrayList<>(); list.add(generateReadWriteEntity("A001-MB1.dev.mesControlWord", 1)); list.add(generateReadWriteEntity("A001-MB1.dev.glassId", glassId)); list.add(generateReadWriteEntity("A001-MB1.dev.width", edgInfo.getWidth())); list.add(generateReadWriteEntity("A001-MB1.dev.height", edgInfo.getHeight())); list.add(generateReadWriteEntity("A001-MB1.dev.thickness", edgInfo.getThickness())); list.add(generateReadWriteEntity("A001-MB1.dev.filmRemove", 0)); miloService.writeToOpcWord(list); } private ReadWriteEntity generateReadWriteEntity(String identifier, Object value) { ReadWriteEntity readWriteEntity = new ReadWriteEntity(); readWriteEntity.setIdentifier(identifier); readWriteEntity.setValue(value); return readWriteEntity; } } hangzhoumesParent/moduleService/CacheGlassModule/src/main/java/com/mes/job/opccallback/CacheGlassStartCallback.java
@@ -7,6 +7,8 @@ import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper; import com.kangaroohy.milo.runner.subscription.SubscriptionCallback; 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; @@ -24,6 +26,7 @@ import org.springframework.stereotype.Service; import javax.annotation.Resource; import java.util.Date; import java.util.List; /** @@ -50,6 +53,9 @@ @Resource EdgStorageDeviceTaskHistoryService edgStorageDeviceTaskHistoryService; @Resource EdgGlassTaskQueueInfoService edgGlassTaskQueueInfoService; @Value("${mes.glassGap}") private int glassGap; @Value("${mes.threshold}") @@ -59,6 +65,7 @@ @Override public void onSubscribe(String identifier, Object value) { log.info("当前正在执行的任务为{}", value); String tableName = identifier.contains("edg_storage_device_one_task") ? EDG_STORAGE_DEVICE_ONE_TASK : EDG_STORAGE_DEVICE_TWO_TASK; EdgStorageDeviceTask task = edgStorageDeviceTaskService.queryTaskMessage(tableName); try { @@ -83,7 +90,7 @@ } } else if (request == 4) { log.info("将启动子改为0"); task.setTaskRunning(Const.GLASS_CACHE_TYPE_EMPTY); task.setTaskRunning(Const.GLASS_CACHE_TYPE_RUNNING); edgStorageDeviceTaskService.updateTaskMessage(tableName, task); } else { finishTask(task, tableName); @@ -273,10 +280,16 @@ 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.setState(Const.GLASS_STATE_NEW); edgGlassTaskQueueInfoService.save(edgInfo); return Boolean.TRUE; } private boolean finishTask(EdgStorageDeviceTask task, String tableName) { log.info("当前任务信息为：{}", task); if (task.getTaskState() <= 4) { log.info("有正在执行的任务，结束"); return Boolean.FALSE; @@ -284,7 +297,7 @@ Integer cell = task.getStartCell(); Integer state = task.getTaskState(); task.setTaskRunning(Const.GLASS_CACHE_TYPE_EMPTY); task.setTaskState(Const.GLASS_CACHE_TYPE_EMPTY); // task.setTaskState(Const.GLASS_CACHE_TYPE_EMPTY); task.setGlassIdOut(""); task.setStartCell(0); task.setWidth(0); @@ -407,6 +420,7 @@ 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; hangzhoumesParent/moduleService/CacheGlassModule/src/main/java/com/mes/job/opccallback/CacheGlassTestCallback.java
New file @@ -0,0 +1,38 @@ package com.mes.job.opccallback; import com.kangaroohy.milo.runner.subscription.SubscriptionCallback; import com.mes.opctask.entity.EdgStorageDeviceTask; import com.mes.opctask.service.EdgStorageDeviceTaskService; import lombok.extern.slf4j.Slf4j; import org.springframework.stereotype.Service; import javax.annotation.Resource; /** * @Author : zhoush * @Date: 2024/10/10 14:13 * @Description: */ @Service @Slf4j public class CacheGlassTestCallback implements SubscriptionCallback { @Resource EdgStorageDeviceTaskService edgStorageDeviceTaskService; @Override public void onSubscribe(String identifier, Object value) { EdgStorageDeviceTask task = edgStorageDeviceTaskService.queryTaskMessage("edg_storage_device_one_task"); try { if (task == null) { log.info("任务表基础数据录入失败，请检查数据是否录入成功"); return; } task.setTaskRunning(task.getTaskRunning() + 1); log.info("当前第{}次执行", task.getTaskRunning()); // task.setTaskState(task.getTaskRunning()); edgStorageDeviceTaskService.updateTaskMessage("edg_storage_device_one_task", task); } catch (Exception e) { log.info("{}", e.getMessage()); } } } hangzhoumesParent/moduleService/CacheGlassModule/src/main/java/com/mes/opctask/entity/EdgStorageDeviceTask.java
@@ -17,6 +17,10 @@ */ private Integer taskRunning; /** * 磨边前玻璃id */ private String glassId; /** * 进片玻璃id */ private String glassIdIn; hangzhoumesParent/moduleService/CacheVerticalGlassModule/src/main/java/com/mes/job/OpcPlcStorageCageTask.java
New file @@ -0,0 +1,295 @@ package com.mes.job; 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.kangaroohy.milo.runner.subscription.SubscriptionCallback; import com.kangaroohy.milo.service.MiloService; import com.mes.bigstorage.entity.BigStorageCage; import com.mes.bigstorage.entity.BigStorageCageDetails; 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.config.Const; import com.mes.damage.entity.Damage; import com.mes.damage.service.DamageService; import com.mes.edgglasstask.service.EdgGlassTaskInfoService; import com.mes.glassinfo.service.GlassInfoService; import com.mes.temperingglass.entity.TemperingGlassInfo; import com.mes.temperingglass.service.TemperingGlassInfoService; import lombok.extern.slf4j.Slf4j; 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.*; import java.util.stream.Collectors; /** * @author SNG-015 */ @Component @Slf4j public class OpcPlcStorageCageTask { @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; @Autowired(required = false) MiloService miloService; @Resource(name = "bigStorageStartCallback") SubscriptionCallback bigStorageStartCallback; @Value("${mes.carWidth}") private Integer carWidth; @Value("${mes.slotWidth}") private Integer slotWidth; @Value("${mes.glassGap}") private Integer glassGap; @Scheduled(fixedDelay = Long.MAX_VALUE) public void startOpcTask() throws Exception { //设备一二的进片请求 miloService.subscriptionFromOpcUa(Arrays.asList("my.device01.x1", "my.device02.x1"), bigStorageStartCallback); } @Scheduled(fixedDelay = Long.MAX_VALUE) public void outOpcTask() throws Exception { //设备1的出片请求 miloService.subscriptionFromOpcUa(Arrays.asList("my.device03.x1"), bigStorageStartCallback); } @Scheduled(fixedDelay = 300) public void updateInGlassStateTask() { 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_NEW)); if (CollectionUtils.isNotEmpty(list)) { log.info("2、获取所有正在进片的玻璃信息id:{}", list); List<String> glassIds = list.stream().map(String::valueOf).collect(Collectors.toList()); List<BigStorageCageFeedTask> inSuccessGlass = bigStorageCageFeedTaskService.list(new LambdaQueryWrapper<BigStorageCageFeedTask>() .in(BigStorageCageFeedTask::getGlassId, glassIds) .in(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_SLOT)); if (CollectionUtils.isNotEmpty(inSuccessGlass)) { log.info("3、获取进片已完成的玻璃信息id:{}", inSuccessGlass); List<Integer> inSuccessGlassSlot = inSuccessGlass.stream().map(BigStorageCageFeedTask::getTargetSlot).collect(Collectors.toList()); List<UpdateBigStorageCageDTO> 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<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); //更新理片笼玻璃尺寸 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<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())); 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()); } //更新格子剩余宽度 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()); } //更新格子剩余宽度 updateSlotRemainBySlots(slotList); log.info("出片任务执行完成"); } Date endDate = new Date(); log.info("大理片笼破损玻璃清除任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime()); return; } public void updateSlotRemainBySlots(List<Integer> slotList) { //获取格子内所有的玻璃信息 List<BigStorageCageDetails> inSlotGlassList = bigStorageCageDetailsService.list(new LambdaQueryWrapper<BigStorageCageDetails>() .in(BigStorageCageDetails::getSlot, slotList).in(BigStorageCageDetails::getState, Const.GLASS_STATE_IN_ALL)); Map<Integer, Double> slotRemainMap = new HashMap<>(); //是否存在有格子非空的玻璃 if (CollectionUtils.isNotEmpty(inSlotGlassList)) { //存在 将格子内的玻璃分别进行更新 slotRemainMap = inSlotGlassList.stream() .collect(Collectors.groupingBy(BigStorageCageDetails::getSlot, Collectors.summingDouble(item -> Math.max(item.getWidth(), item.getHeight()) + glassGap))); slotRemainMap.forEach((e, v) -> { double remainWidth = slotWidth - v >= 0 ? slotWidth - v : 0; bigStorageCageService.update(new LambdaUpdateWrapper<BigStorageCage>().set(BigStorageCage::getRemainWidth, remainWidth) .eq(BigStorageCage::getSlot, e)); }); } //过滤不存在玻璃的格子 将宽度重置为原始宽度5000 Set<Integer> remainSlotList = slotRemainMap.keySet(); slotList.removeAll(remainSlotList); if (CollectionUtils.isNotEmpty(slotList)) { bigStorageCageService.update(new LambdaUpdateWrapper<BigStorageCage>().set(BigStorageCage::getRemainWidth, slotWidth) .in(BigStorageCage::getSlot, slotList)); } } } hangzhoumesParent/moduleService/CacheVerticalGlassModule/src/main/java/com/mes/job/opccallback/BigStorageStartCallback.java
New file @@ -0,0 +1,824 @@ package com.mes.job.opccallback; 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.baomidou.mybatisplus.core.toolkit.CollectionUtils; import com.github.yulichang.toolkit.JoinWrappers; import com.github.yulichang.wrapper.MPJLambdaWrapper; import com.kangaroohy.milo.runner.subscription.SubscriptionCallback; 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.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.Service; import javax.annotation.Resource; import java.util.ArrayList; import java.util.Date; import java.util.List; import java.util.Map; import java.util.stream.Collectors; /** * @Author : zhoush * @Date: 2024/10/28 21:22 * @Description: */ @Service @Slf4j public class BigStorageStartCallback implements SubscriptionCallback { @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 = ""; @Override public void onSubscribe(String identifier, Object value) { //todo:获取任务列表 String tableName = ""; //todo:按照表明获取伍信息 List<BigStorageCageFeedTask> tasks = new ArrayList<>(); if (CollectionUtils.isEmpty(tasks)) { log.info("卧转立上没有玻璃"); //todo 与卧转立交互，将请求字大车请求变为0，确保订阅任务可再次执行 return; } List<String> glassIds = tasks.stream().map(BigStorageCageFeedTask::getGlassId).collect(Collectors.toList()); List<GlassInfo> glassInfos = glassInfoService.list(new LambdaQueryWrapper<GlassInfo>().in(GlassInfo::getGlassId, glassIds)); computeIsTemperingTargetByLine(glassInfos, tasks); } @Scheduled(fixedDelay = 10000) public void plcToHomeEdgOutTask() { String mesToPLCAddress = ""; List<BigStorageCageOutTask> outingList = bigStorageCageOutTaskService.list(new LambdaQueryWrapper<BigStorageCageOutTask>() .eq(BigStorageCageOutTask::getTaskState, Const.BIG_STORAGE_OUT_NEW)); if (CollectionUtils.isNotEmpty(outingList)) { log.info("有正在执行出片的任务，结束当前出片线程"); return; } if (redisUtil.getCacheObject("temperingSwitch")) { //是否有正在钢化的玻璃 List<TemperingGlassInfo> temperingGlassInfoList = temperingGlassInfoService.selectJoinList(TemperingGlassInfo.class, new MPJLambdaWrapper<TemperingGlassInfo>() .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("有正在出片的钢化任务"); computeOutMoreGlassInfo(temperingGlassInfoList, Boolean.TRUE, mesToPLCAddress); return; } //是否有人工下片任务 有直接出 // List<BigStorageCageDetails> artificialList = bigStorageCageDetailsService.list(new LambdaQueryWrapper<BigStorageCageDetails>() // .eq(BigStorageCageDetails::getState, Const.GLASS_STATE_ARTIFICIAL).orderByDesc(BigStorageCageDetails::getWidth)); 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)) { computeOutMoreGlassInfo(artificialList, Boolean.FALSE, mesToPLCAddress); return; } //钢化优先：获取理片笼 玻璃小片 破损表 数量 判断笼内版图是否到齐 List<TemperingLayoutDTO> temperingLayoutDTOList = bigStorageCageDetailsService.temperingIsAll(); if (CollectionUtils.isNotEmpty(temperingLayoutDTOList)) { //玻璃到齐包括已出片的 //到齐，将玻璃小片数据存入钢化小片表，逻辑生成出片任务 结束 for (TemperingLayoutDTO item : temperingLayoutDTOList) { if (redisUtil.getCacheObject("temperingengineerId").equals(item.getEngineerId())) { List<TemperingGlassInfo> 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); computeOutMoreGlassInfo(temperingGlassInfoList, Boolean.TRUE, mesToPLCAddress); 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; if (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)) { List<BigStorageCageOutTask> 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, new Date())); } //新增调度任务 bigStorageCageOutTaskService.saveBatch(outTasks); //更新理片笼详情表调度的后的玻璃位置信息：生成任务后先将玻璃格子位置进行调整，玻璃状态改为调度中，新增调度完成任务，处理调度完成后玻璃状态改为100. List<String> glassList = list.stream().map(BigStorageCageDetails::getGlassId).collect(Collectors.toList()); bigStorageCageDetailsService.update(new LambdaUpdateWrapper<BigStorageCageDetails>().set(BigStorageCageDetails::getState, Const.GLASS_STATE_SCHEDULE_ING) .set(BigStorageCageBaseInfo::getSlot, second.getSlot()).in(BigStorageCageDetails::getGlassId, glassList)); //两次更新笼子的剩余尺寸：第一次防止有玻璃继续进调度后的笼子，第二次更新：计算格子的实际尺寸 // 仅更新调度后的格子信息：起始格子完成后更新：防止调度出片过程中有新玻璃进入， // todo:临时解决报错 // 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); // } return; } } /** * 确认字清空 */ @Scheduled(fixedDelay = 300) public void confirmClear() { PlcParameterObject plcParameterObject = S7object.getinstance().PlcMesObject; String d01ToMES = plcParameterObject.getPlcParameter("D01ToMES").getValue(); String d04ToMES = plcParameterObject.getPlcParameter("D04ToMES").getValue(); String mesD01Address = plcParameterObject.getPlcParameter("MESToD01").getAddress(); String mesD04Address = plcParameterObject.getPlcParameter("MESToD04").getAddress(); String d03ToMES = plcParameterObject.getPlcParameter("D03ToMES").getValue(); String d05ToMES = plcParameterObject.getPlcParameter("D05ToMES").getValue(); String mesD03Address = plcParameterObject.getPlcParameter("MESToD03").getAddress(); String mesD05Address = plcParameterObject.getPlcParameter("MESToD05").getAddress(); if (!REQUEST_WORD.equals(d01ToMES)) { S7object.getinstance().plccontrol.writeWord(mesD01Address, 0); } if (!REQUEST_WORD.equals(d04ToMES)) { S7object.getinstance().plccontrol.writeWord(mesD04Address, 0); } if (!REQUEST_WORD.equals(d03ToMES)) { S7object.getinstance().plccontrol.writeWord(mesD03Address, 0); } if (!REQUEST_WORD.equals(d05ToMES)) { S7object.getinstance().plccontrol.writeWord(mesD05Address, 0); } } /** * 进片状态修改 */ @Scheduled(fixedDelay = 300) public void feedStatusUpdate() { PlcParameterObject plcParameterObject = S7object.getinstance().PlcMesObject; List<String> glassIds1 = new ArrayList<>(); List<String> glassIds2 = new ArrayList<>(); for (int i = 1; i <= 6; i++) { String line1GlassId = plcParameterObject.getPlcParameter("D03ID" + i).getValue(); if (StringUtils.isNotEmpty(line1GlassId)) { glassIds1.add(line1GlassId); } String line2GlassId = plcParameterObject.getPlcParameter("D05ID" + i).getValue(); if (StringUtils.isNotEmpty(line2GlassId)) { glassIds2.add(line2GlassId); } } List<BigStorageCageFeedTask> bigStorageCageFeedTasks1 = bigStorageCageFeedTaskService.list( new LambdaQueryWrapper<BigStorageCageFeedTask>() .eq(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_NEW) .eq(BigStorageCageFeedTask::getLine, Const.A09_OUT_TARGET_POSITION) ); List<BigStorageCageFeedTask> bigStorageCageFeedTasks2 = bigStorageCageFeedTaskService.list( new LambdaQueryWrapper<BigStorageCageFeedTask>() .eq(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_NEW) .eq(BigStorageCageFeedTask::getLine, Const.A10_OUT_TARGET_POSITION) ); if (CollectionUtils.isNotEmpty(bigStorageCageFeedTasks1) && CollectionUtils.isNotEmpty(glassIds1)) { List<String> matchingIds1 = bigStorageCageFeedTasks1.stream() .map(BigStorageCageFeedTask::getGlassId) .filter(glassIds1::contains) .distinct() .collect(Collectors.toList()); bigStorageCageFeedTaskService.update( new LambdaUpdateWrapper<BigStorageCageFeedTask>() .in(BigStorageCageFeedTask::getGlassId, matchingIds1) .lt(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_SLOT) .set(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_UP) ); } if (CollectionUtils.isNotEmpty(bigStorageCageFeedTasks2) && CollectionUtils.isNotEmpty(glassIds2)) { List<String> matchingIds2 = bigStorageCageFeedTasks2.stream() .map(BigStorageCageFeedTask::getGlassId) .filter(glassIds2::contains) .distinct() .collect(Collectors.toList()); bigStorageCageFeedTaskService.update( new LambdaUpdateWrapper<BigStorageCageFeedTask>() .in(BigStorageCageFeedTask::getGlassId, matchingIds2) .lt(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_SLOT) .set(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_UP) ); } if (CollectionUtils.isEmpty(glassIds1)) { bigStorageCageFeedTaskService.update( new LambdaUpdateWrapper<BigStorageCageFeedTask>() .eq(BigStorageCageFeedTask::getLine, Const.A09_OUT_TARGET_POSITION) .eq(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_UP) .gt(BigStorageCageFeedTask::getTargetSlot, 0) .lt(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_SLOT) .set(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_CAR) ); } if (CollectionUtils.isEmpty(glassIds2)) { bigStorageCageFeedTaskService.update( new LambdaUpdateWrapper<BigStorageCageFeedTask>() .eq(BigStorageCageFeedTask::getLine, Const.A10_OUT_TARGET_POSITION) .eq(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_UP) .gt(BigStorageCageFeedTask::getTargetSlot, 0) .lt(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_SLOT) .set(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_CAR) ); } } /** * 按照玻璃id判断玻璃状态及卧转立是否可直接启动 */ public Boolean judgeGlassTypeStatus(String glassId, Integer line, String mesAddress) { //判断此玻璃是在笼内或已生成进片任务 BigStorageCageFeedTask bigStorageCageFeedTask = bigStorageCageFeedTaskService.getOne( new LambdaQueryWrapper<BigStorageCageFeedTask>() .lt(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_SLOT) .eq(BigStorageCageFeedTask::getGlassId, glassId) ); BigStorageCageDetails bigStorageCageDetails = bigStorageCageDetailsService.getOne( new LambdaQueryWrapper<BigStorageCageDetails>() .eq(BigStorageCageDetails::getGlassId, glassId) .ne(BigStorageCageDetails::getState, Const.GLASS_STATE_IN) ); if (bigStorageCageFeedTask != null || bigStorageCageDetails != null) { log.info("此玻璃存任务或已在笼内"); return Boolean.TRUE; } //1、获取任务表中相邻玻璃 List<EdgGlassTaskInfo> edgGlassTaskInfoList; edgGlassTaskInfoList = edgGlassTaskInfoService.list(new LambdaQueryWrapper<EdgGlassTaskInfo>() .eq(EdgGlassTaskInfo::getLine, line) .apply("time >= (select time from edg_glass_task_info where line='" + line + "' and glass_id = '" + glassId + "' and deleted = 0)") .orderByAsc(EdgGlassTaskInfo::getTime)); if (edgGlassTaskInfoList.size() == 0) { edgGlassTaskInfoList = edgGlassTaskInfoService.list(new QueryWrapper<EdgGlassTaskInfo>() .select("Top 1 *") .eq("glass_id", glassId) ); log.info("在尺寸表中获取玻璃信息{}", edgGlassTaskInfoList); if (edgGlassTaskInfoList.size() == 0) { GlassInfo glassInfo = glassInfoService.getOne( new LambdaQueryWrapper<GlassInfo>() .eq(GlassInfo::getGlassId, glassId) ); EdgGlassTaskInfo edgGlassTaskInfo = new EdgGlassTaskInfo(); BeanUtils.copyProperties(glassInfo, edgGlassTaskInfo); edgGlassTaskInfo.setWidth((int) glassInfo.getWidth()); edgGlassTaskInfo.setHeight((int) glassInfo.getHeight()); edgGlassTaskInfoList.add(edgGlassTaskInfo); log.info("在玻璃信息表中获取玻璃信息{}", edgGlassTaskInfoList); } } 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 { if (glassCount < inCarMaxSize + 1) { addFeedTask(glassId, line, Const.BIG_STORAGE_IN_RUN, widthFirst, heightFirst); } else { return Boolean.FALSE; } } } 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, heightFirst); } else { if (glassCount < inCarMaxSize + 1) { addFeedTask(glassId, line, Const.BIG_STORAGE_IN_RUN, widthFirst, heightFirst); } else { return Boolean.FALSE; } } } else { if (glassCount < inCarMaxSize + 1) { addFeedTask(glassId, line, Const.BIG_STORAGE_IN_RUN, widthFirst, heightFirst); } else { return Boolean.FALSE; } } } else { flag = Boolean.FALSE; } } //向plc发送进片确认 if (flag) { //向plc写入确认字 PlcParameterObject plcParameterObject = S7object.getinstance().PlcMesObject; int returnData = 1; int count = 1; while (returnData != 0) { S7object.getinstance().plccontrol.writeWord(mesAddress, 1); if (Const.A10_OUT_TARGET_POSITION.equals(line)) { returnData = Integer.parseInt(plcParameterObject.getPlcParameter("D04ToMES").getValue()); } else { returnData = Integer.parseInt(plcParameterObject.getPlcParameter("D01ToMES").getValue()); } // returnData = S7object.getinstance().plccontrol.readWord(mesAddress, 1).get(0); log.info("进卧转立第{}次发送确认字完成，地址为：{},写入的内容为{}", count++, mesAddress, 1); } } //记录无法放下玻璃，后续判断启动 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()); //删除理片笼表拿走/破损数据数据 damageService.deleteByGlassId(glassId); Damage damage = new Damage(); damage.setGlassId(glassId); damage.setWorkingProcedure("磨边"); damage.setLine(line); damage.setType(1); damage.setRemark("进大理片"); damageService.insertDamage(damage); return bigStorageCageFeedTaskService.save(bigStorageCageFeedTask); } /** * 获取需要启动的线路：两条线都可启动 获取第一片玻璃版图id最小 版序最大的线路 * * @return 需要启动的线路 */ public Integer getStartLine() { List<BigStorageCageFeedTask> taskList = bigStorageCageFeedTaskService.list(new LambdaQueryWrapper<BigStorageCageFeedTask>() .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<String, Integer> taskMap = taskList.stream().collect(Collectors.toMap(BigStorageCageFeedTask::getGlassId, BigStorageCageFeedTask::getLine)); GlassInfo glassInfo = glassInfoService.getOne(new LambdaQueryWrapper<GlassInfo>() .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<BigStorageCageFeedTask> taskList = bigStorageCageFeedTaskService.list(new LambdaQueryWrapper<BigStorageCageFeedTask>() .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<String> glassIds = taskList.stream().map(BigStorageCageFeedTask::getGlassId).collect(Collectors.toList()); List<GlassInfo> glassInfos = glassInfoService.list(new LambdaQueryWrapper<GlassInfo>().in(GlassInfo::getGlassId, glassIds)); return computeIsTemperingTargetByLine(glassInfos, taskList); } /** * 是否钢化玻璃进笼目标位置 * * @param glassInfos 当条线卧转立所有玻璃 * @param taskList 当条线卧转立所有任务 */ private boolean computeIsTemperingTargetByLine(List<GlassInfo> glassInfos, List<BigStorageCageFeedTask> taskList) { //1、将玻璃信息集合转为glassid为key的map Map<String, GlassInfo> 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); //todo:2、获取目标格子信息 BigStorageDTO bigStorageDTO = bigStorageCageDetailsService.queryTargetSlotByTempering(info); //3、临时更新格子的剩余尺寸：防止相邻玻璃进同一格子造成剩余尺寸不足，玻璃越界的情况，任务完成后再次更新大理片笼表剩余宽度（按照笼内玻璃数量更新大理片笼剩余尺寸） bigStorageCageService.update(new LambdaUpdateWrapper<BigStorageCage>().set(BigStorageCage::getRemainWidth, bigStorageDTO.getWidth() - Math.max(info.getWidth(), info.getHeight()) - 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); } return Boolean.TRUE; } private void sendTaskListToPLC(List<BigStorageCageFeedTask> 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, taskList.get(i - 1).getLine(), taskList.get(i - 1).getTargetSlot()); } int returnData = 1; int count = 1; while (returnData != 0) { s7control.writeWord(outLine, 2); if (line.equals(Const.A09_OUT_TARGET_POSITION)) { returnData = Integer.parseInt(plcMesObject.getPlcParameter("D03ToMES").getValue()); } else { returnData = Integer.parseInt(plcMesObject.getPlcParameter("D05ToMES").getValue()); } // returnData = s7control.readWord(outLine, 1).get(0); log.info("已向plc第{}次发送进片任务确认，地址为：{},写入的内容为{}", count++, outLine, 2); } } /** * 出片一次仅生成一车玻璃 * * @param list * @param isTempering * @param mesToPLCAddress * @param <T> * @return */ private <T extends BigStorageCageBaseInfo> Boolean computeOutGlassInfo(List<T> list, Boolean isTempering, String mesToPLCAddress) { //任务数据 获取车子存放玻璃最大数量 玻璃间隔 List<BigStorageCageOutTask> bigStorageCageOutTaskList = new ArrayList<>(); //打车剩余尺寸 Integer remainWidth = carWidth; int maxX = 0; for (T e : list) { if (bigStorageCageOutTaskList.size() >= outCarMaxSize || Math.max((int) e.getWidth(), (int) e.getHeight()) > remainWidth) { break; } remainWidth = remainWidth - Math.max((int) e.getWidth(), (int) e.getHeight()) - 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, 0, 0, 1, new Date())); maxX = Math.max(maxX, e.getXCoordinate()); } else { break; } } else { bigStorageCageOutTaskList.add(new BigStorageCageOutTask(e.getGlassId(), e.getSlot(), Const.ARTIFICIAL_OUT_TARGET_POSITION, e.getWidth() * 10, e.getHeight(), 0, 0, 1, new Date())); } } Assert.isFalse(CollectionUtils.isEmpty(bigStorageCageOutTaskList), "未获取出片数据，结束出片任务"); log.info("获取出片任务数据{}条，执行保存", bigStorageCageOutTaskList.size()); bigStorageCageOutTaskService.saveBatch(bigStorageCageOutTaskList); List<String> glassIds = bigStorageCageOutTaskList.stream().map(BigStorageCageOutTask::getGlassId).collect(Collectors.toList()); log.info("将出片玻璃{}玻璃状态改为已出片", glassIds); bigStorageCageDetailsService.update(new LambdaUpdateWrapper<BigStorageCageDetails>() .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; } /** * 出片一次生成一炉玻璃 * * @param list * @param isTempering * @param mesToPLCAddress * @param <T> * @return */ public <T extends BigStorageCageBaseInfo> Boolean computeOutMoreGlassInfo(List<T> list, Boolean isTempering, String mesToPLCAddress) { //任务数据 获取车子存放玻璃最大数量 玻璃间隔 List<BigStorageCageOutTask> 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 (serialNumber > outCarMaxSize || maxLength > remainWidth) { remainWidth = carWidth; trainNumber = trainNumber + 1; serialNumber = 1; maxX = 0; } 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, new Date())); maxX = Math.max(maxX, e.getXCoordinate()); } else { remainWidth = carWidth - maxLength - glassGap; trainNumber = trainNumber + 1; serialNumber = 1; maxX = e.getXCoordinate(); bigStorageCageOutTaskList.add(new BigStorageCageOutTask(e.getGlassId(), e.getSlot(), Const.TEMPERING_OUT_TARGET_POSITION, e.getWidth() * 10, e.getHeight(), trainNumber, serialNumber++, 1, new Date())); } } else { bigStorageCageOutTaskList.add(new BigStorageCageOutTask(e.getGlassId(), e.getSlot(), Const.ARTIFICIAL_OUT_TARGET_POSITION, e.getWidth() * 10, e.getHeight(), trainNumber, serialNumber++, 1, new Date())); } } Assert.isFalse(CollectionUtils.isEmpty(bigStorageCageOutTaskList), "未获取出片数据，结束出片任务"); log.info("获取出片任务数据{}条，执行保存", bigStorageCageOutTaskList.size()); for (BigStorageCageOutTask bigStorageCageOutTask : bigStorageCageOutTaskList ) { bigStorageCageOutTaskService.save(bigStorageCageOutTask); } // bigStorageCageOutTaskService.saveBatch(bigStorageCageOutTaskList); List<String> glassIds = bigStorageCageOutTaskList.stream().map(BigStorageCageOutTask::getGlassId).collect(Collectors.toList()); log.info("将出片玻璃{}玻璃状态改为已出片", glassIds); bigStorageCageDetailsService.update(new LambdaUpdateWrapper<BigStorageCageDetails>() .set(BigStorageCageDetails::getState, Const.GLASS_STATE_OUT_ING) .in(BigStorageCageDetails::getGlassId, glassIds) .ne(BigStorageCageDetails::getState, Const.GLASS_STATE_OUT)); return Boolean.TRUE; } private BigStorageDTO queryTargetSlotByTempering(GlassInfo glassInfo) { MPJLambdaWrapper<BigStorageCage> wrapper = new MPJLambdaWrapper<>(BigStorageCage.class) .selectAll(BigStorageCage.class) .leftJoin(BigStorageCageDetails.class, BigStorageCageDetails::getSlot, BigStorageCage::getSlot) .eq(BigStorageCage::getEnableState, Const.SLOT_ON) .in(BigStorageCageDetails::getState, Const.GLASS_STATE_IN_ALL_ZERO) .eq(BigStorageCageDetails::getEngineerId, glassInfo.getEngineerId()) .eq(BigStorageCageDetails::getTemperingLayoutId, glassInfo.getTemperingLayoutId()) .gt(BigStorageCage::getRemainWidth, Math.max(glassInfo.getWidth(), glassInfo.getHeight())) .last("limit 1"); if (glassInfo.getTemperingLayoutId() == 0) { wrapper.eq(BigStorageCageDetails::getFlowCardId, glassInfo.getFlowCardId()) .eq(BigStorageCageDetails::getLayer, glassInfo.getLayer()); // wrapper.eq(BigStorageCageDetails::getWidth, glassInfo.getWidth()).eq(BigStorageCageDetails::getHeight, glassInfo.getHeight()); } else { wrapper.eq(BigStorageCageDetails::getTemperingFeedSequence, glassInfo.getTemperingFeedSequence() + 1); } BigStorageCage bigStorageCage = bigStorageCageService.selectJoinOne(BigStorageCage.class, wrapper); return null; } @Scheduled(fixedDelay = 300) public void querySizeByEngineerTask() { log.info("查询结果：{}", querySizeByEngineer("P24072402", 1, 10, 8)); log.info("查询结果：{}", querySizeByEngineer("P24072402", 1, 5, 8)); } public BigStorageDTO querySizeByEngineer(String engineerId, int temperingLayoutId, int temperingFeedSequence, double thickness) { BigStorageDTO bigStorageDTO = null; BigStorageCage bigStorageCage = null; //获取笼内当前版图每个格子已有玻璃的最小版序 获取笼内当前版图的所有玻璃信息 List<BigStorageCageDetails> cageDetailsList = bigStorageCageDetailsService.list(new QueryWrapper<BigStorageCageDetails>() .select("slot", "min(tempering_feed_sequence) as tempering_feed_sequence") .eq("engineer_id", engineerId).eq("tempering_layout_id", temperingLayoutId) .in("state", Const.GLASS_STATE_IN_ALL_ZERO).groupBy("slot").orderByAsc("min(tempering_feed_sequence)")); if (CollectionUtils.isNotEmpty(cageDetailsList)) { Integer minLength = cageDetailsList.stream().filter(e -> e.getTemperingFeedSequence() > temperingFeedSequence) .mapToInt(BigStorageCageDetails::getTemperingFeedSequence).min().orElse(1000); List<GlassInfo> infoList = glassInfoService.list(new LambdaQueryWrapper<GlassInfo>() .notInSql(GlassInfo::getGlassId, "select glass_id from damage where tempering_layout_id = " + temperingLayoutId + " and engineer_id = '" + engineerId + "'") .eq(GlassInfo::getTemperingLayoutId, temperingLayoutId).eq(GlassInfo::getEngineerId, engineerId).orderByAsc(GlassInfo::getTemperingFeedSequence)); int remainWidth = carWidth; int trainNumber = 1; int serialNumber = 0; int min = 0; int temp = infoList.get(0).getTemperingFeedSequence(); int slot = 0; int resultTrainNumber = 0; for (GlassInfo e : infoList) { int maxLength = Math.max((int) e.getWidth(), (int) e.getHeight()); if (serialNumber >= outCarMaxSize || maxLength > remainWidth || e.getTemperingFeedSequence() >= minLength) { if (resultTrainNumber != 0) { min = temp; break; } temp = e.getTemperingFeedSequence(); remainWidth = carWidth; trainNumber = trainNumber + 1; serialNumber = 0; } if (temperingFeedSequence == e.getTemperingFeedSequence()) { resultTrainNumber = trainNumber; } remainWidth = remainWidth - maxLength - glassGap > 0 ? remainWidth - maxLength - glassGap : 0; serialNumber += 1; log.info("{},{},{}", trainNumber, remainWidth, serialNumber); if (e.getTemperingFeedSequence().equals(infoList.get(infoList.size() - 1).getTemperingFeedSequence())) { min = temp; } } for (BigStorageCageDetails item : cageDetailsList) { if (min <= item.getTemperingFeedSequence() && item.getTemperingFeedSequence() < minLength) { slot = item.getSlot(); bigStorageCage = bigStorageCageService.getOne(new LambdaQueryWrapper<BigStorageCage>() .eq(BigStorageCage::getSlot, slot).eq(BigStorageCage::getEnableState, Const.SLOT_ON)); break; } } } if (bigStorageCage != null) { bigStorageDTO = new BigStorageDTO(); bigStorageDTO.setWidth(bigStorageCage.getRemainWidth()); bigStorageDTO.setSlot(bigStorageCage.getSlot()); bigStorageDTO.setDeviceId(bigStorageCage.getDeviceId()); return bigStorageDTO; } bigStorageCage = bigStorageCageService.getOne(new LambdaQueryWrapper<BigStorageCage>() .eq(BigStorageCage::getEnableState, Const.SLOT_ON) .eq(BigStorageCage::getRemainWidth, slotWidth) .inSql(BigStorageCage::getDeviceId, "select distinct device_id from big_storage_cage_details where engineer_id = '" + engineerId + "' and tempering_layout_id = " + temperingLayoutId) .last("limit 1")); if (null != bigStorageCage) { log.info("根据版图id找到笼子内的目标格子：{}", bigStorageCage.getSlot()); bigStorageDTO = new BigStorageDTO(); bigStorageDTO.setWidth(bigStorageCage.getRemainWidth()); bigStorageDTO.setSlot(bigStorageCage.getSlot()); bigStorageDTO.setDeviceId(bigStorageCage.getDeviceId()); return bigStorageDTO; } //获取玻璃的厚度：重新选笼子需要按照笼子可放玻璃厚度进行选择 因为子查询排序对主sql无影响，所以先执行子查询获取顺序，然后一次去查询 List<Integer> deviceUsedList = bigStorageCageService.queryFreeDeviceByUsed(thickness); for (Integer item : deviceUsedList) { bigStorageCage = bigStorageCageService.getOne(new LambdaQueryWrapper<BigStorageCage>() .eq(BigStorageCage::getRemainWidth, slotWidth) .eq(BigStorageCage::getEnableState, Const.SLOT_ON) .eq(BigStorageCage::getDeviceId, item) .last("limit 1")); if (null != bigStorageCage) { log.info("按照存笼玻璃格子数占用最少方式获取信息格子为：{}", bigStorageCage.getSlot()); bigStorageDTO = new BigStorageDTO(); bigStorageDTO.setWidth(bigStorageCage.getRemainWidth()); bigStorageDTO.setSlot(bigStorageCage.getSlot()); bigStorageDTO.setDeviceId(bigStorageCage.getDeviceId()); return bigStorageDTO; } } Assert.isTrue(null != bigStorageCage, "没有空余的笼子存放玻璃"); return bigStorageDTO; } } hangzhoumesParent/moduleService/LoadGlassModule/src/main/java/com/mes/engineering/entity/Engineering.java
File was deleted hangzhoumesParent/moduleService/LoadGlassModule/src/main/java/com/mes/job/OpcLoadGlassTask.java
New file @@ -0,0 +1,210 @@ package com.mes.job; import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper; import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper; import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper; import com.mes.common.config.Const; import com.mes.engineering.entity.Engineering; import com.mes.engineering.mapper.EngineeringMapper; import com.mes.opctask.entity.LoadGlassDeviceTask; import com.mes.opctask.entity.LoadGlassDeviceTaskHistory; import com.mes.opctask.service.LoadGlassDeviceTaskHistoryService; import com.mes.opctask.service.LoadGlassDeviceTaskService; import com.mes.rawglassdetails.entity.RawGlassStorageDetails; import com.mes.rawglassdetails.service.RawGlassStorageDetailsService; import com.mes.uppattenusage.entity.UpPattenUsage; import com.mes.uppattenusage.entity.vo.UpPattenUsageVO; import com.mes.uppattenusage.mapper.UpPattenUsageMapper; import lombok.extern.slf4j.Slf4j; import org.springframework.beans.BeanUtils; import org.springframework.stereotype.Component; import org.springframework.util.CollectionUtils; import javax.annotation.Resource; import java.util.Arrays; import java.util.Date; import java.util.List; import java.util.Map; import java.util.stream.Collectors; /** * @Author : zhoush * @Date: 2024/10/23 14:30 * @Description: */ @Component @Slf4j public class OpcLoadGlassTask { @Resource private EngineeringMapper engineeringMapper; @Resource private LoadGlassDeviceTaskService loadGlassDeviceTaskService; @Resource private RawGlassStorageDetailsService rawGlassStorageDetailsService; @Resource private LoadGlassDeviceTaskHistoryService loadGlassDeviceTaskHistoryService; @Resource private UpPattenUsageMapper upPattenUsageMapper; private static final List<Integer> LOAD_STATION_01 = Arrays.asList(101, 102); private static final List<Integer> LOAD_STATION_02 = Arrays.asList(103, 104); private static final Integer LOAD_GLASS_ONE_DEVICE = 5; private static final Integer LOAD_GLASS_TWO_DEVICE = 6; private static final String LOAD_GLASS_DEVICE_ONE_TASK = "load_glass_device_one_task"; private static final String LOAD_GLASS_DEVICE_TWO_TASK = "load_glass_device_two_task"; //设备id 上片位信息 任务表不一致 历史任务表公用一张 新增任务/任务结束，后会在历史表中新增一条记录并在结束后更新任务 一个任务即可 //定时任务扫描上片位有没有原片 //1、是否有在执行的任务 //2、1号上片位是否有原片，原片尺寸是否和上片待上片的尺寸一致 //3、1号无原片，且没有架子，2号上片位尺寸是否和带上片尺寸一致 //4、不一致可能出现玻璃破损导致的上一架原片数量不够 public void opcLoadGlassOne() { opcLoadGlassChild(LOAD_GLASS_DEVICE_ONE_TASK, LOAD_GLASS_ONE_DEVICE); } public void opcLoadGlassTwo() { opcLoadGlassChild(LOAD_GLASS_DEVICE_TWO_TASK, LOAD_GLASS_TWO_DEVICE); } public void opcLoadGlassOneFinish() { opcLoadGlassFinishChid(LOAD_GLASS_DEVICE_ONE_TASK, LOAD_GLASS_ONE_DEVICE); } public void opcLoadGlassTwoFinish() { opcLoadGlassFinishChid(LOAD_GLASS_DEVICE_TWO_TASK, LOAD_GLASS_TWO_DEVICE); } private void opcLoadGlassChild(String tableName, Integer deviceId) { Engineering engineering = engineeringMapper.selectOne(new LambdaQueryWrapper<Engineering>() .eq(Engineering::getState, Const.ENGINEERING_RUNNING).eq(Engineering::getStationCell, deviceId)); if (null == engineering) { log.info("{}上片线，没有工程任务", deviceId); } //任务暂停 LoadGlassDeviceTask task = loadGlassDeviceTaskService.queryTaskMessage(tableName); if ("1".equals(task.getTaskState())) { log.info("有正在执行的上片任务，结束本地上片请求"); return; } List<UpPattenUsageVO> pattenUsageList = upPattenUsageMapper.queryRawGlassByEngineeringId(engineering.getEngineerId()); log.info("按照当前获取到正在需要上片的原片信息有：{}", pattenUsageList); if (CollectionUtils.isEmpty(pattenUsageList)) { log.info("当前工程需要上片的原片信息为空，任务已结束"); //todo：是否将工程状态改为已完成 return; } Map<String, List<UpPattenUsageVO>> upListMap = pattenUsageList.stream() .collect(Collectors.groupingBy(UpPattenUsageVO::getGroupNumber)); log.info("获取当前需要上片的原片数据"); List<UpPattenUsageVO> usageVOS = upListMap.get(0); // 获取1号上片位是有架子且有玻璃 List<Integer> loadStation = LOAD_GLASS_DEVICE_ONE_TASK.equals(tableName) ? LOAD_STATION_01 : LOAD_STATION_02; List<RawGlassStorageDetails> loadStationList = rawGlassStorageDetailsService.list(new LambdaQueryWrapper<RawGlassStorageDetails>() .inSql(RawGlassStorageDetails::getSlot, "select slot from raw_glass_storage_station where enable_state = 1") .eq(RawGlassStorageDetails::getState, Const.RAW_GLASS_STATE_IN) .eq(RawGlassStorageDetails::getDeviceId, deviceId)); if (CollectionUtils.isEmpty(loadStationList)) { log.info("当前上片线路两个上片位都没有原片信息，结束本次上片任务，等待仓储调度任务"); return; } RawGlassStorageDetails oneLoadStation = loadStationList.stream().filter(e -> e.getSlot().equals(loadStation.get(0))).findFirst().orElse(null); if (null == oneLoadStation) { RawGlassStorageDetails twoLoadStation = loadStationList.stream().filter(e -> e.getSlot().equals(loadStation.get(1))).findFirst().orElse(null); if (!compareRawSize(usageVOS.get(0), oneLoadStation)) { log.info("二号上片位有架子，原片数量为0或者原片信息与待上片尺寸不一致，结束本次上片任务，等待仓储调度任务"); return; } int number = Math.min(twoLoadStation.getRemainQuantity(), usageVOS.size()); //生成上片任务 task.setTotalCount(number); task.setTaskRunning(Const.ENGINEERING_RUNNING); task.setRawGlassWidth((int) usageVOS.get(0).getWidth()); task.setRawGlassHeight((int) usageVOS.get(0).getHeight()); task.setSlot(loadStation.get(1)); loadGlassDeviceTaskService.updateTaskMessage(tableName, task); saveHistoryTask(task, deviceId); return; } //尺寸不一样或者原片数量大于0 if (!compareRawSize(usageVOS.get(0), oneLoadStation)) { log.info("一号上片位有架子，原片数量为0或者原片信息与待上片尺寸不一致，结束本次上片任务，等待仓储调度任务"); return; } //生成上片任务 int number = Math.min(oneLoadStation.getRemainQuantity(), usageVOS.size()); task.setTotalCount(number); task.setTaskRunning(Const.ENGINEERING_RUNNING); task.setRawGlassWidth((int) usageVOS.get(0).getWidth()); task.setRawGlassHeight((int) usageVOS.get(0).getHeight()); task.setSlot(loadStation.get(0)); loadGlassDeviceTaskService.updateTaskMessage(tableName, task); saveHistoryTask(task, deviceId); } private void opcLoadGlassFinishChid(String tableName, Integer deviceId) { LoadGlassDeviceTask task = loadGlassDeviceTaskService.queryTaskMessage(tableName); if (task.getTaskState() <= 1) { log.info("无任务或任务正在执行中"); return; } //获取任务完成情况 // 已完成数量 破损数量 Integer finishCount = task.getFinishCount(); Integer damageCount = task.getDamageCount(); //更新当前架子上的原片剩余情况 rawGlassStorageDetailsService.update(new UpdateWrapper<RawGlassStorageDetails>() .inSql("slot", "select slot from raw_glass_storage_station where enable_state = 1") .eq("slot", task.getSlot()) .eq("state", Const.RAW_GLASS_STATE_IN) .set("remain_quantity", "remain_quantity - " + (finishCount + damageCount))); //更新工程下的原片数量 todo:sql待优化 upPattenUsageMapper.update(null, new LambdaUpdateWrapper<UpPattenUsage>() .inSql(UpPattenUsage::getId, " SELECT id FROM up_patten_usage ORDER BY id ASC LIMIT 10") .set(UpPattenUsage::getState, Const.LOAD_RAW_GLASS_SUCCESS)); //todo:任务表数据情况 task.setTaskRunning(0); task.setTotalCount(0); task.setRawGlassWidth(0); task.setRawGlassHeight(0); task.setSlot(0); loadGlassDeviceTaskService.updateTaskMessage(tableName, task); loadGlassDeviceTaskHistoryService.update(new LambdaUpdateWrapper<LoadGlassDeviceTaskHistory>() .set(LoadGlassDeviceTaskHistory::getTaskState, Const.RAW_GLASS_TASK_SUCCESS) .eq(LoadGlassDeviceTaskHistory::getTaskState, Const.RAW_GLASS_TASK_NEW) .eq(LoadGlassDeviceTaskHistory::getStation, deviceId) ); } private boolean saveHistoryTask(LoadGlassDeviceTask task, Integer deviceId) { LoadGlassDeviceTaskHistory taskHistory = new LoadGlassDeviceTaskHistory(); BeanUtils.copyProperties(task, taskHistory); taskHistory.setStation(deviceId); taskHistory.setCreateTime(new Date()); taskHistory.setTaskState(Const.RAW_GLASS_TASK_NEW); loadGlassDeviceTaskHistoryService.save(taskHistory); return Boolean.TRUE; } /** * 尺寸一样并且原片数量大于0 * * @param upPattenUsage * @param details * @return */ private boolean compareRawSize(UpPattenUsage upPattenUsage, RawGlassStorageDetails details) { boolean flag = upPattenUsage.getWidth() == details.getPatternWidth() && upPattenUsage.getHeight() == details.getPatternHeight() && upPattenUsage.getThickness() == details.getPatternThickness() && upPattenUsage.getFilmsId().equals(details.getFilmsId()); return flag && details.getRemainQuantity() > 0; } } hangzhoumesParent/moduleService/LoadGlassModule/src/main/java/com/mes/opctask/entity/LoadGlassDeviceTask.java
New file @@ -0,0 +1,58 @@ package com.mes.opctask.entity; import lombok.Data; import java.util.Date; /** * (LoadGlassDeviceOneTask)表实体类 * * @author makejava * @since 2024-11-06 16:00:10 */ @Data public class LoadGlassDeviceTask { /** * 任务请求 0无任务 1上片 */ private Integer taskRunning; /** * 原片宽 */ private Integer rawGlassWidth; /** * 原片高 */ private Integer rawGlassHeight; /** * 上片位编号 */ private Integer slot; /** * 任务状态 0默认空任务 1执行中 2结束任务 */ private Integer taskState; /** * 创建时间 */ private Date createTime; /** * 更新时间 */ private Date updateTime; /** * 上片总数量 */ private Integer totalCount; /** * 已完成数量 */ private Integer finishCount; /** * 破损数量 */ private Integer damageCount; }
New file @@ -0,0 +1,66 @@ package com.mes.opctask.entity; import lombok.Data; import java.util.Date; /** * (LoadGlassDeviceTaskHistory)表实体类 * * @author makejava * @since 2024-11-06 22:23:00 */ @SuppressWarnings("serial") @Data public class LoadGlassDeviceTaskHistory { /** * 历史任务id */ private Long id; /** * 任务请求 0无任务 1上片 */ private Integer taskRunning; /** * 原片宽 */ private Integer rawGlassWidth; /** * 原片高 */ private Integer rawGlassHeight; /** * 上片设备编号 */ private Integer station; /** * 上片位编号 */ private Integer slot; /** * 任务状态 0默认空任务 1执行中 2结束任务 */ private Integer taskState; /** * 创建时间 */ private Date createTime; /** * 更新时间 */ private Date updateTime; /** * 上片总数量 */ private Integer totalCount; /** * 已完成数量 */ private Integer finishCount; /** * 破损数量 */ private Integer damageCount; }
New file @@ -0,0 +1,15 @@ package com.mes.opctask.mapper; import com.baomidou.mybatisplus.core.mapper.BaseMapper; import com.mes.opctask.entity.LoadGlassDeviceTaskHistory; /** * (LoadGlassDeviceTaskHistory)表数据库访问层 * * @author makejava * @since 2024-11-06 22:22:59 */ public interface LoadGlassDeviceTaskHistoryDao extends BaseMapper<LoadGlassDeviceTaskHistory> { }
New file @@ -0,0 +1,19 @@ package com.mes.opctask.mapper; import com.mes.opctask.entity.LoadGlassDeviceTask; import org.apache.ibatis.annotations.Param; /** * (LoadGlassDeviceOneTask)表数据库访问层 * * @author makejava * @since 2024-11-06 16:00:09 */ public interface LoadGlassDeviceTaskMapper { LoadGlassDeviceTask queryTaskMessage(String tableName); boolean updateTaskMessage(@Param("tableName") String tableName, @Param("task") LoadGlassDeviceTask loadGlassDeviceTask); }
New file @@ -0,0 +1,15 @@ package com.mes.opctask.service; import com.baomidou.mybatisplus.extension.service.IService; import com.mes.opctask.entity.LoadGlassDeviceTaskHistory; /** * (LoadGlassDeviceTaskHistory)表服务接口 * * @author makejava * @since 2024-11-06 22:23:00 */ public interface LoadGlassDeviceTaskHistoryService extends IService<LoadGlassDeviceTaskHistory> { }
New file @@ -0,0 +1,20 @@ package com.mes.opctask.service; import com.mes.opctask.entity.LoadGlassDeviceTask; import org.apache.ibatis.annotations.Param; /** * (LoadGlassDeviceOneTask)表服务接口 * * @author makejava * @since 2024-11-06 16:00:13 */ public interface LoadGlassDeviceTaskService { LoadGlassDeviceTask queryTaskMessage(String tableName); boolean updateTaskMessage(@Param("tableName") String tableName, @Param("task") LoadGlassDeviceTask loadGlassDeviceTask); }
New file @@ -0,0 +1,32 @@ package com.mes.opctask.service.impl; import com.mes.opctask.entity.LoadGlassDeviceTask; import com.mes.opctask.mapper.LoadGlassDeviceTaskMapper; import com.mes.opctask.service.LoadGlassDeviceTaskService; import org.springframework.stereotype.Service; import javax.annotation.Resource; /** * (LoadGlassDeviceOneTask)表服务实现类 * * @author makejava * @since 2024-11-06 16:00:16 */ @Service public class LoadGlassDeviceOneTaskServiceImpl implements LoadGlassDeviceTaskService { @Resource LoadGlassDeviceTaskMapper loadGlassDeviceTaskMapper; @Override public LoadGlassDeviceTask queryTaskMessage(String tableName) { return loadGlassDeviceTaskMapper.queryTaskMessage(tableName); } @Override public boolean updateTaskMessage(String tableName, LoadGlassDeviceTask loadGlassDeviceTask) { return loadGlassDeviceTaskMapper.updateTaskMessage(tableName, loadGlassDeviceTask); } }
New file @@ -0,0 +1,19 @@ package com.mes.opctask.service.impl; import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl; import com.mes.opctask.entity.LoadGlassDeviceTaskHistory; import com.mes.opctask.mapper.LoadGlassDeviceTaskHistoryDao; import com.mes.opctask.service.LoadGlassDeviceTaskHistoryService; import org.springframework.stereotype.Service; /** * (LoadGlassDeviceTaskHistory)表服务实现类 * * @author makejava * @since 2024-11-06 22:23:00 */ @Service public class LoadGlassDeviceTaskHistoryServiceImpl extends ServiceImpl<LoadGlassDeviceTaskHistoryDao, LoadGlassDeviceTaskHistory> implements LoadGlassDeviceTaskHistoryService { }
@@ -2,7 +2,6 @@ import com.mes.engineering.entity.Engineering; import com.mes.engineering.service.EngineeringService; import com.mes.glassinfo.entity.GlassInfo; import com.mes.glassinfo.service.GlassInfoService; import com.mes.pp.service.OptimizeProjectService; import com.mes.uppattenusage.entity.UpPattenUsage; hangzhoumesParent/moduleService/LoadGlassModule/src/main/resources/mapper/LoadGlassDeviceTaskMapper.xml
New file @@ -0,0 +1,34 @@ <?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd"> <mapper namespace="com.mes.opctask.mapper.LoadGlassDeviceTaskMapper"> <resultMap id="baseMap" type="com.mes.opctask.entity.LoadGlassDeviceTask"> <id column="task_running" property="taskRunning"/> <result column="raw_glass_width" property="rawGlassWidth"/> <result column="raw_glass_height" property="rawGlassHeight"/> <result column="slot" property="slot"/> <result column="task_state" property="taskState"/> <result column="create_time" property="createTime"/> <result column="update_time" property="updateTime"/> <result column="total_count" property="totalCount"/> <result column="finish_count" property="finishCount"/> <result column="damage_count" property="damageCount"/> </resultMap> <select id="queryTaskMessage" resultMap="baseMap"> select * from ${tableName} limit 1 </select> <update id="updateTaskMessage"> UPDATE ${tableName} SET task_running = #{task.taskRunning}, raw_glass_width = #{task.rawGlassWidth}, raw_glass_height = #{task.rawGlassHeight}, slot = #{task.slot}, total_count = #{task.totalCount} </update> </mapper>
