1、钢化查询添加显示工程名称 2、中空任务界面缺片详情修改

ZengTao

2025-11-11 aa5d2f68e1d97f7a1b20fa15e1bde9195544bb3e

 hangzhoumesParent/moduleService/CacheGlassModule/src/main/java/com/mes/job/OpcCacheGlassNewTask.java

@@ -8,6 +8,8 @@
import com.github.xingshuangs.iot.protocol.s7.serializer.S7Serializer;
import com.kangaroohy.milo.model.ReadWriteEntity;
import com.kangaroohy.milo.service.MiloService;
import com.mes.alarm.entity.ProductAlarmInfo;
import com.mes.alarm.service.ProductAlarmInfoService;
import com.mes.common.config.Const;
import com.mes.common.config.ConstSysConfig;
import com.mes.damage.service.DamageService;
@@ -113,17 +115,35 @@
    private String glassIdOne = "";
    private String glassIdTwo = "";

    @Resource
    private ProductAlarmInfoService productAlarmInfoService;

    private static final String ALARM_MODULE = "磨边";
    private static final String ALARM_TYPE1 = "一线卧式理片笼";
    private static final String ALARM_TYPE2 = "二线卧式理片笼";
    private static final String ALARM_CODE_NOGLASS = "noGlass";
    private static final String ALARM_CODE_ID = "idSame";

    @Scheduled(fixedDelay = 1000)
    public void startOneOpcTask() throws Exception {
        List<ProductAlarmInfo> alarmInfos = productAlarmInfoService.list(new LambdaQueryWrapper<ProductAlarmInfo>()
                .eq(ProductAlarmInfo::getState, Const.LOAD_RAW_GLASS_NEW)
                .eq(ProductAlarmInfo::getAlarmModule, ALARM_MODULE)
                .eq(ProductAlarmInfo::getAlarmType, ALARM_TYPE1));
        if (CollectionUtil.isNotEmpty(alarmInfos)) {
            log.info("界面报警，等待人工干预处理");
            return;
        }
        S7DataWL s7DataWLTwo = s7SerializerWLTwo.read(S7DataWL.class);
        S7DataWL s7DataWLOne = s7SerializerWLOne.read(S7DataWL.class);
        S7DataWLExtra s7DataWLExtraTwo = s7SerializerWLTwo.read(S7DataWLExtra.class);
        log.info("一线卧理: {}", s7DataWLOne);
        //获取第二条线路的卧式理片笼状态
        Boolean twoInkageEntity = s7DataWLTwo.getDeviceState();
        //默认只跑一台卧式理片,两条线路都可以走
        int cellFlag = 1;
        //如果两条线都启动则只能跑一条线
        if (twoInkageEntity != null && !twoInkageEntity) {
        if (!twoInkageEntity && !Const.OUT_DISABLE.equals(s7DataWLExtraTwo.getD06SlotState())) {
            cellFlag = 2;
        }
        startOneOpcTaskChild(s7DataWLOne, 1, cellFlag);
@@ -131,15 +151,25 @@

    @Scheduled(fixedDelay = 1000)
    public void startTwoOpcTask() throws Exception {
        List<ProductAlarmInfo> alarmInfos = productAlarmInfoService.list(new LambdaQueryWrapper<ProductAlarmInfo>()
                .eq(ProductAlarmInfo::getState, Const.LOAD_RAW_GLASS_NEW)
                .eq(ProductAlarmInfo::getAlarmModule, ALARM_MODULE)
                .eq(ProductAlarmInfo::getAlarmType, ALARM_TYPE2));
        if (CollectionUtil.isNotEmpty(alarmInfos)) {
            log.info("界面报警，等待人工干预处理");
            return;
        }
        S7DataWL s7DataWLOne = s7SerializerWLOne.read(S7DataWL.class);
        S7DataWL s7DataWLTwo = s7SerializerWLTwo.read(S7DataWL.class);
        S7DataWLExtra s7DataWLExtraTwo = s7SerializerWLTwo.read(S7DataWLExtra.class);
        log.info("二线卧理: {}", s7DataWLTwo);
        Boolean oneInkageEntity = s7DataWLOne.getDeviceState();
        int cellFlag = 1;
        if (oneInkageEntity != null && !oneInkageEntity) {
        if (!oneInkageEntity && !Const.OUT_DISABLE.equals(s7DataWLExtraTwo.getD06SlotState())) {
            cellFlag = 2;
        }
        startOneOpcTaskChild(s7DataWLTwo, 2, cellFlag);

    }

    private void startOneOpcTaskChild(S7DataWL task, int device, int cellFlag) throws Exception {
@@ -173,15 +203,15 @@
            //进片任务
            log.info("设备：{}状态：{}", device, request);
            log.info("进片任务：进片玻璃id为：{}", task.getGlassIdIn());
            intoTask(task, "", device);
            intoTask(task, device);
        } else if (request == 2 && taskRunning == 0) {
            //出片任务
            outTask(task, "", device, cellFlag);
            outTask(task, device, cellFlag);
        } else if (request == 3 && taskRunning == 0) {
            //直通任务
            log.info("设备：{}状态：{}", device, request);
            if (!outTask(task, "", device, cellFlag)) {
                intoTask(task, "", device);
            if (!outTask(task, device, cellFlag)) {
                intoTask(task, device);
            }
        } else if (request == 4) {
            log.info("设备：{}状态：{}", device, request);
@@ -218,7 +248,7 @@
    }

    @Scheduled(fixedDelay = 1000)
    public void edgTwoOpcTask() throws Exception {
    public void edgTwoOpcTask() {
        S7DataWL s7DataWLTwo = s7SerializerWLTwo.read(S7DataWL.class);
        String glassId = s7DataWLTwo.getGlassId();
        log.info("2号线玻璃id{},历史id{}", glassId, glassIdTwo);
@@ -229,7 +259,7 @@
        edgTaskChild(glassId, 2);
    }

    private void edgTaskChild(String glassId, int cell) throws Exception {
    private void edgTaskChild(String glassId, int cell) {
        ratio = sysConfigService.queryConfigValue(ConstSysConfig.CACHE_RATIO);
        GlassInfo glassInfo = glassInfoService.getOne(new LambdaQueryWrapper<GlassInfo>().eq(GlassInfo::getGlassId, glassId).last("limit 1"));
        if (glassInfo == null) {
@@ -270,19 +300,41 @@
        }
    }

    private boolean intoTask(S7DataWL task, String tableName, int deviceId) {
    private boolean intoTask(S7DataWL task, int deviceId) {
        Date startDate = new Date();
        log.info("开始执行进片任务，任务信息为：{},表名为：{},设备id:{},开始时间：{}", task, tableName, deviceId, startDate);
        log.info("开始执行进片任务，任务信息为：{},设备id:{},开始时间：{}", task, deviceId, startDate);
        //获取玻璃的基本信息
        GlassInfo glassInfo = glassInfoService.getOne(new LambdaQueryWrapper<GlassInfo>().eq(GlassInfo::getGlassId, task.getGlassIdIn()));
        if (null == glassInfo) {
        if (null == glassInfo && StringUtils.isNotBlank(task.getGlassIdIn())) {
            log.info("进片玻璃信息不存在，玻璃id:{}", task.getGlassIdIn());
            ProductAlarmInfo alarmInfo = new ProductAlarmInfo();
            alarmInfo.setState(Const.LOAD_RAW_GLASS_NEW);
            alarmInfo.setAlarmModule(ALARM_MODULE);
            if (deviceId == 1) {
                alarmInfo.setAlarmType(ALARM_TYPE1);
            } else {
                alarmInfo.setAlarmType(ALARM_TYPE2);
            }
            alarmInfo.setAlarmCode(ALARM_CODE_NOGLASS);
            alarmInfo.setAlarmMessage(task.getGlassIdIn());
            productAlarmInfoService.save(alarmInfo);
            Date endDate = new Date();
            log.info("结束进片任务设备为{}，结束时间为：{}，共耗时：{}ms", deviceId, endDate, endDate.getTime() - startDate.getTime());
            return Boolean.FALSE;
        }
        if (glassInIdOne.equals(task.getGlassIdIn()) || glassInIdTwo.equals(task.getGlassIdIn())) {
            log.info("玻璃id与上次相同，禁止进片");
            ProductAlarmInfo alarmInfo = new ProductAlarmInfo();
            alarmInfo.setState(Const.LOAD_RAW_GLASS_NEW);
            alarmInfo.setAlarmModule(ALARM_MODULE);
            if (deviceId == 1) {
                alarmInfo.setAlarmType(ALARM_TYPE1);
            } else {
                alarmInfo.setAlarmType(ALARM_TYPE2);
            }
            alarmInfo.setAlarmCode(ALARM_CODE_ID);
            alarmInfo.setAlarmMessage(task.getGlassIdIn());
            productAlarmInfoService.save(alarmInfo);
            Date endDate = new Date();
            log.info("结束进片任务设备为{}，结束时间为：{}，共耗时：{}ms", deviceId, endDate, endDate.getTime() - startDate.getTime());
            return Boolean.FALSE;
@@ -338,8 +390,26 @@
        return Boolean.TRUE;
    }

    private boolean outTask(S7DataWL task, String tableName, int deviceId, int cellFlag) throws Exception {
    private boolean outTask(S7DataWL task, int deviceId, int cellFlag) {
        Date startDate = new Date();
        GlassInfo glassInfo = glassInfoService.getOne(new LambdaQueryWrapper<GlassInfo>().eq(GlassInfo::getGlassId, task.getGlassIdIn()));
        if (null == glassInfo && StringUtils.isNotBlank(task.getGlassIdIn())) {
            log.info("直通玻璃信息不存在，玻璃id:{}", task.getGlassIdIn());
            ProductAlarmInfo alarmInfo = new ProductAlarmInfo();
            alarmInfo.setState(Const.LOAD_RAW_GLASS_NEW);
            alarmInfo.setAlarmModule(ALARM_MODULE);
            if (deviceId == 1) {
                alarmInfo.setAlarmType(ALARM_TYPE1);
            } else {
                alarmInfo.setAlarmType(ALARM_TYPE2);
            }
            alarmInfo.setAlarmCode(ALARM_CODE_NOGLASS);
            alarmInfo.setAlarmMessage(task.getGlassIdIn());
            productAlarmInfoService.save(alarmInfo);
            Date endDate = new Date();
            log.info("结束进片任务设备为{}，结束时间为：{}，共耗时：{}ms", deviceId, endDate, endDate.getTime() - startDate.getTime());
            return Boolean.FALSE;
        }
        //获取对应的设备状态信息
        S7DataWL s7DataWLOne = s7SerializerWLOne.read(S7DataWL.class);
        S7DataWL s7DataWLTwo = s7SerializerWLTwo.read(S7DataWL.class);
@@ -349,8 +419,9 @@
        Integer d06OutState = s7DataWLExtraTwo.getD06SlotState();
        //状态有3中情况：0空闲 1忙碌 2禁用
        //两条线都为禁用则不出玻璃
        log.info("当前设备为：{},一号设备任务信息：{}，二号设备任务信息：{}，d06任务信息：{}", deviceId, s7DataWLOne, s7DataWLTwo, d06OutState);
        if (Const.OUT_DISABLE.equals(oneOutState) && Const.OUT_DISABLE.equals(twoOutState)) {
            log.info("A09、A10为{},{}非自动状态，无法出片", oneOutState, oneOutState);
            log.info("设备{}:A09、A10为{},{}非自动状态，无法出片", deviceId, oneOutState, oneOutState);
            return Boolean.FALSE;
        }
        //获取d06片台状态
@@ -359,15 +430,14 @@
        // 3:二号线一对多的情况下，获取一号线磨边前片台C08的状态，C08非禁用时，一号线将按照D06片台状态觉得出片
        if (cellFlag == 2) {
            if (deviceId == 1) {

                twoOutState = twoOutState & d06OutState;
            } else {
                oneOutState = oneOutState & d06OutState;
            }
        }

        log.info("开始执行出片/直通任务，任务信息为：{},表名为：{},设备id:{},开始时间：{},一号线状态：{}，二号线状态：{}",
                task, tableName, deviceId, startDate, oneOutState, twoOutState);
        log.info("开始执行出片/直通任务，任务信息为：{},设备id:{},开始时间：{},一号线状态：{}，二号线状态：{}",
                task, deviceId, startDate, oneOutState, twoOutState);
        //获取当前需要走那条线
        int cell = 0;
        if (cellFlag == 1) {
@@ -377,30 +447,32 @@
                cell = Const.TWO_OUT_TARGET_POSITION;
            } else if (Const.OUT_FREE.equals(oneOutState)) {
                cell = Const.ONE_OUT_TARGET_POSITION;
            } else {
            } else if (Const.OUT_BUSY.equals(twoOutState)) {
                cell = Const.TWO_OUT_TARGET_POSITION;
            } else if (Const.OUT_BUSY.equals(oneOutState)) {
                cell = Const.ONE_OUT_TARGET_POSITION;
            } else {
                return Boolean.FALSE;
            }
        }
        if (Const.OUT_FREE.equals(oneOutState) && Const.OUT_FREE.equals(twoOutState)) {
            if (cellFlag == 2) {
                if (!outChildTask(task, tableName, deviceId, cell, startDate)) {
                    cell = cell == Const.ONE_OUT_TARGET_POSITION ? Const.TWO_OUT_TARGET_POSITION : Const.ONE_OUT_TARGET_POSITION;
                    return outChildTask(task, tableName, deviceId, cell, startDate);
                }
            } else {
                return outChildTask(task, tableName, deviceId, cell, startDate);
        log.info("{}线路计算完成：{}", deviceId, cell);
        if (cellFlag == 2) {
            if (!outChildTask(task, deviceId, cell, startDate)) {
                cell = cell == Const.ONE_OUT_TARGET_POSITION ? Const.TWO_OUT_TARGET_POSITION : Const.ONE_OUT_TARGET_POSITION;
                return outChildTask(task, deviceId, cell, startDate);
            }
        } else {
            return outChildTask(task, tableName, deviceId, cell, startDate);
            return outChildTask(task, deviceId, cell, startDate);
        }
        return Boolean.TRUE;
    }

    private boolean outChildTask(S7DataWL task, String tableName, int deviceId, int cell, Date startDate) {
    private boolean outChildTask(S7DataWL task, int deviceId, int cell, Date startDate) {
        EdgStorageCageDetails edgStorageCageDetails = null;

        //笼内是版图相差是否超过阈值
        boolean flag = queryMaxMinDiffByDevice(threshold, deviceId);
        log.info("{}阈值计算完成：{}", deviceId, flag);
        if (flag) {
            //先找最小版图版序的玻璃小片
            EdgStorageCageDetails minEdgDetails = edgStorageCageDetailsService.getOne(new LambdaQueryWrapper<EdgStorageCageDetails>()
@@ -424,15 +496,18 @@
                );
            }
        }
        log.info("{}按照阈值查找结果：{}", deviceId, edgStorageCageDetails);
        if (null == edgStorageCageDetails) {
//        获取历史表中上次任务最后一片尺寸
            EdgStorageDeviceTaskHistory edgeData = edgStorageDeviceTaskHistoryService.getOne(new LambdaQueryWrapper<EdgStorageDeviceTaskHistory>()
                    .eq(EdgStorageDeviceTaskHistory::getDeviceId, cell)
                    .eq(EdgStorageDeviceTaskHistory::getEndCell, cell)
                    .in(EdgStorageDeviceTaskHistory::getTaskType, Const.GLASS_CACHE_TYPE_OUT, Const.GLASS_CACHE_TYPE_THROUGH)
                    .orderByDesc(EdgStorageDeviceTaskHistory::getId).last("limit 1"));
            log.info("{}获取上次任务信息：{}", deviceId, edgeData);
            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(), cell, maxThickness);
                if (null == edgStorageCageDetails && StringUtils.isNotBlank(task.getGlassIdIn())) {
                    GlassInfo glassInInfo = glassInfoService.getOne(new LambdaQueryWrapper<GlassInfo>()
@@ -448,11 +523,13 @@
                }
            }
        }
        log.info("{}获取历史表中上次任务最后一片尺寸：{}", deviceId, edgStorageCageDetails);
        //前面已经尺寸问题处理完毕，开始计算无相同尺寸的新玻璃小片
        if (null == edgStorageCageDetails) {
            edgStorageCageDetails = edgStorageCageDetailsService.queryEdgStorageDetailsByLimitSize(deviceId, Integer.parseInt(task.getCurrentCell().toString()), 0, 0,
                    cell, minOneFirstLength, minOneSecondLength, maxTwoFirstLength, maxTwoSecondLength, maxThickness);
        }
        log.info("{}开始计算无相同尺寸的新玻璃小片：{}", deviceId, edgStorageCageDetails);
        if (edgStorageCageDetails == null && StringUtils.isNotBlank(task.getGlassIdIn())) {
            //和上次任务不存在相同尺寸
            GlassInfo glassInInfo = glassInfoService.getOne(new LambdaQueryWrapper<GlassInfo>().eq(GlassInfo::getGlassId, task.getGlassIdIn()));
@@ -469,6 +546,7 @@
                log.info("直通任务目标线路为{},进片玻璃尺寸为{}*{},不符合出片条件", cell, maxLength, minLength);
            }
        }
        log.info("{}直通任务：{}", deviceId, edgStorageCageDetails);
        if (edgStorageCageDetails == null) {
            //和上次任务不存在相同尺寸
            log.info("笼内没有玻璃了");
@@ -480,7 +558,7 @@
            if (3 != task.getTaskState()) {
                return Boolean.FALSE;
            }
            log.info("5、直通任务,将玻璃信息插入卧式理片笼,当前玻璃信息:{}", edgStorageCageDetails);
            log.info("5、{}直通任务,将玻璃信息插入卧式理片笼,当前玻璃信息:{}", edgStorageCageDetails);
            if (glassInIdOne.equals(task.getGlassIdIn()) || glassInIdTwo.equals(task.getGlassIdIn())) {
                log.info("玻璃id与上次相同，禁止进片");
                return Boolean.FALSE;
@@ -494,11 +572,7 @@
                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"));
            EdgStorageCage storageCage = edgStorageCageService.selectNearestEmpty(Integer.parseInt(task.getCurrentCell().toString()), deviceId, Boolean.TRUE);
            Assert.isTrue(null != storageCage, "格子已满,无法执行直通任务");
            log.info("3、查询卧式理片笼里面的空格:{}", storageCage);
            edgStorageCageDetails.setSlot(storageCage.getSlot());
@@ -534,7 +608,6 @@
        task.setStartCell(edgStorageCageDetails.getSlot());
        task.setTaskRunning(taskType);
        task.setEndCell(cell);
//        edgStorageDeviceTaskService.updateTaskMessage(tableName, task);
        if (deviceId == 1) {
            s7SerializerWLOne.write(
                    S7DataWL.builder()