1、中空任务队列显示bug修复，缺片详情破损后再查询条件添加

ZengTao

2025-10-12 ea2fdc85d876c680e042034d1cbb7c1ca030b5b7

 hangzhoumesParent/moduleService/hollowGlassModule/src/main/java/com/mes/job/OpcPlcStorageCageHollowTask.java

@@ -10,6 +10,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.base.entity.HollowBigStorageCageBaseInfo;
import com.mes.bigstoragecagetask.entity.BigStorageCageTask;
import com.mes.bigstoragecagetask.service.BigStorageCageTaskService;
@@ -101,8 +103,20 @@
    @Qualifier("CMJ1ModbusTcp")
    ModbusTcp CMJ1ModbusTcp;

    @Resource
    private ProductAlarmInfoService productAlarmInfoService;

    private static final String BIG_STORAGE_CAGE_IN_TWO_TASK = "big_storage_cage_in_two_task";
    private static final String BIG_STORAGE_CAGE_OUT_TWO_TASK = "big_storage_cage_out_two_task";

    private static final List<Integer> ONE_LINE_FIRST = Arrays.asList(930, 931, 932);
    private static final List<Integer> TWO_LINE_FIRST = Arrays.asList(931, 930, 932);


    private static final String ALARM_MODULE = "中空";
    private static final String ALARM_TYPE = "中空大理片";
    private static final String ALARM_CODE_SIZE = "sizeSame";
    private static final String ALARM_CODE_ID = "idSame";

    /**
     * 直通格子
@@ -115,6 +129,14 @@

    @Scheduled(fixedDelay = 1000)
    public void inBigStorageTask() {
        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_TYPE));
        if (CollectionUtil.isNotEmpty(alarmInfos)) {
            log.info("界面报警，等待人工干预处理");
            return;
        }
        S7DataZKDLPOne s7DataZKDLPOne = s7SerializerZKDLPOne.read(S7DataZKDLPOne.class);
        log.info("进片任务读取s7DataZKDLPOne:{}", s7DataZKDLPOne);
        Boolean inkageEntity = s7DataZKDLPOne.getMesControl();
@@ -157,6 +179,13 @@
        for (Map.Entry<String, Long> entry : glassCountMap.entrySet()) {
            if (entry.getValue() > 1) {
                log.info("进片玻璃{}存在相同，结束本次任务", entry.getKey());
                ProductAlarmInfo alarmInfo = new ProductAlarmInfo();
                alarmInfo.setState(Const.LOAD_RAW_GLASS_NEW);
                alarmInfo.setAlarmModule(ALARM_MODULE);
                alarmInfo.setAlarmType(ALARM_TYPE);
                alarmInfo.setAlarmCode(ALARM_CODE_ID);
                alarmInfo.setAlarmMessage(entry.getKey());
                productAlarmInfoService.save(alarmInfo);
                //向plc发送报警:同一车进片玻璃存在相同
                s7DataZKDLPOne = new S7DataZKDLPOne();
                s7DataZKDLPOne.setAlramSignal(2);
@@ -169,6 +198,16 @@
        if (CollectionUtil.isNotEmpty(detailsList)) {
            log.info("理片笼存在相同的进片玻璃{}，结束本次任务", detailsList);
            //向plc发送报警:理片笼存在相同的进片玻璃
            List<String> sameGlassIds = detailsList.stream()
                    .map(HollowBigStorageCageDetails::getGlassId)
                    .collect(Collectors.toList());
            ProductAlarmInfo alarmInfo = new ProductAlarmInfo();
            alarmInfo.setState(Const.LOAD_RAW_GLASS_NEW);
            alarmInfo.setAlarmModule(ALARM_MODULE);
            alarmInfo.setAlarmType(ALARM_TYPE);
            alarmInfo.setAlarmCode(ALARM_CODE_ID);
            alarmInfo.setAlarmMessage(sameGlassIds.toString());
            productAlarmInfoService.save(alarmInfo);
            s7DataZKDLPOne = new S7DataZKDLPOne();
            s7DataZKDLPOne.setAlramSignal(4);
            s7SerializerZKDLPOne.write(s7DataZKDLPOne);
@@ -237,51 +276,49 @@
        List<HollowBigStorageCageHistoryTask> historyTasks = new ArrayList<>();

        Integer glassGap = sysConfigService.queryConfigValue(ConstSysConfig.HOLLOW_GLASS_GAP);
        try {
            log.info("开始计算目标格子,玻璃id有：{}", inTaskList);
            if (slotMaxHeight > Math.min(glassInfoList.get(0).getWidth(), glassInfoList.get(0).getHeight()) && glassInfoList.get(0).getThickness() < slotMaxthickness) {
                for (BigStorageCageTask task : inTaskList) {
                    GlassInfo info = glassListMap.get(task.getGlassId()).get(0);
                    HollowBigStorageDTO bigStorageDTO = hollowGlassRelationInfoService.queryHollowTargetSlot(info.getFlowCardId(), info.getGlassType(),

        log.info("开始计算目标格子,玻璃id有：{}", inTaskList);
        if (slotMaxHeight > Math.min(glassInfoList.get(0).getWidth(), glassInfoList.get(0).getHeight()) && glassInfoList.get(0).getThickness() < slotMaxthickness) {
            for (BigStorageCageTask task : inTaskList) {
                GlassInfo info = glassListMap.get(task.getGlassId()).get(0);
                HollowBigStorageDTO bigStorageDTO = null;
                try {
                    bigStorageDTO = hollowGlassRelationInfoService.queryHollowTargetSlot(info.getFlowCardId(), info.getGlassType(),
                            info.getWidth(), info.getHeight(), info.getTotalLayer(), info.getLayer());
//            临时更新格子的剩余尺寸：防止相邻玻璃进同一格子造成剩余尺寸不足，玻璃越界的情况，任务完成后再次更新大理片笼表剩余宽度（按照笼内玻璃数量更新大理片笼剩余尺寸）
                    hollowBigStorageCageService.update(new LambdaUpdateWrapper<HollowBigStorageCage>()
                            .set(HollowBigStorageCage::getRemainWidth, bigStorageDTO.getRemainWidth() - Math.max(info.getWidth(), info.getHeight()) - glassGap)
                            .eq(HollowBigStorageCage::getSlot, bigStorageDTO.getSlot()));
                    task.setTargetSlot(bigStorageDTO.getSlot());
                    task.setGlassId(info.getGlassId());
                    //存放历史任务
                    HollowBigStorageCageHistoryTask historyTask = new HollowBigStorageCageHistoryTask();
                    BeanUtils.copyProperties(task, historyTask);
                    historyTask.setTaskType(Const.BIG_STORAGE_AFTER_IN);
                    historyTask.setGlassCount(glassInfoList.size());
                    historyTask.setTaskState(Const.ENGINEERING_NEW);
                    historyTasks.add(historyTask);
                    //存放详情数据
                    HollowBigStorageCageDetails cageDetails = new HollowBigStorageCageDetails();
                    BeanUtils.copyProperties(bigStorageDTO, cageDetails);
                    BeanUtils.copyProperties(info, cageDetails);
                    cageDetails.setState(Const.GLASS_STATE_NEW);
                    cageDetails.setSequence(bigStorageDTO.getSlotSequence());
                    cageDetails.setGap(glassGap);
                    cageDetails.setId(null);
                    hollowBigStorageCageDetailsService.save(cageDetails);
                } catch (Exception exception) {
                    log.info("进片任务执行中发生异常：{}", exception);
                    //保存故障信息
                    ProductAlarmInfo alarmInfo = new ProductAlarmInfo();
                    alarmInfo.setState(Const.LOAD_RAW_GLASS_NEW);
                    alarmInfo.setAlarmModule(ALARM_MODULE);
                    alarmInfo.setAlarmType(ALARM_TYPE);
                    alarmInfo.setAlarmCode(ALARM_CODE_SIZE);
                    alarmInfo.setAlarmMessage(info.getGlassId());
                    productAlarmInfoService.save(alarmInfo);
                    //重置详情表数据
                    hollowBigStorageCageDetailsService.update(new LambdaUpdateWrapper<HollowBigStorageCageDetails>()
                            .set(HollowBigStorageCageDetails::getState, Const.GLASS_STATE_TAKE)
                            .eq(HollowBigStorageCageDetails::getState, Const.GLASS_STATE_NEW));
                    //重置中空关系表数据
                    hollowGlassRelationInfoService.update(new LambdaUpdateWrapper<HollowGlassRelationInfo>()
                            .set(HollowGlassRelationInfo::getGlassId, cageDetails.getGlassId())
                            .set(HollowGlassRelationInfo::getTemperingLayoutId, cageDetails.getTemperingLayoutId())
                            .set(HollowGlassRelationInfo::getTemperingFeedSequence, cageDetails.getTemperingFeedSequence())
                            .set(HollowGlassRelationInfo::getEngineerId, cageDetails.getEngineerId())
                            .set(HollowGlassRelationInfo::getState, Const.HOLLOW_RELATION_OCCUPY)
                            .eq(HollowGlassRelationInfo::getFlowCardId, bigStorageDTO.getFlowCardId())
                            .eq(HollowGlassRelationInfo::getLayer, bigStorageDTO.getLayer())
                            .eq(HollowGlassRelationInfo::getVirtualSlot, bigStorageDTO.getVirtualSlot())
                            .eq(HollowGlassRelationInfo::getSlotSequence, bigStorageDTO.getSlotSequence())
                            .eq(HollowGlassRelationInfo::getHollowSequence, bigStorageDTO.getHollowSequence())
                            .set(HollowGlassRelationInfo::getGlassId, null)
                            .set(HollowGlassRelationInfo::getTemperingLayoutId, null)
                            .set(HollowGlassRelationInfo::getTemperingFeedSequence, null)
                            .set(HollowGlassRelationInfo::getEngineerId, null)
                            .set(HollowGlassRelationInfo::getState, Const.HOLLOW_RELATION_NEW)
                            .eq(HollowGlassRelationInfo::getState, Const.HOLLOW_RELATION_OCCUPY)
                    );
                    //将格子尺寸恢复
                    hollowBigStorageCageService.resetCage();
                    return;
                }
            } else {
                BigStorageCageTask task = inTaskList.get(0);
                task.setTargetSlot(THROUGH_SLOT);

//            临时更新格子的剩余尺寸：防止相邻玻璃进同一格子造成剩余尺寸不足，玻璃越界的情况，任务完成后再次更新大理片笼表剩余宽度（按照笼内玻璃数量更新大理片笼剩余尺寸）
                hollowBigStorageCageService.update(new LambdaUpdateWrapper<HollowBigStorageCage>()
                        .set(HollowBigStorageCage::getRemainWidth, bigStorageDTO.getRemainWidth() - Math.max(info.getWidth(), info.getHeight()) - glassGap)
                        .eq(HollowBigStorageCage::getSlot, bigStorageDTO.getSlot()));
                task.setTargetSlot(bigStorageDTO.getSlot());
                task.setGlassId(info.getGlassId());
                //存放历史任务
                HollowBigStorageCageHistoryTask historyTask = new HollowBigStorageCageHistoryTask();
                BeanUtils.copyProperties(task, historyTask);
@@ -289,37 +326,52 @@
                historyTask.setGlassCount(glassInfoList.size());
                historyTask.setTaskState(Const.ENGINEERING_NEW);
                historyTasks.add(historyTask);
                GlassInfo info = glassInfoList.get(0);
                //存放详情数据
                HollowBigStorageCageDetails cageDetails = new HollowBigStorageCageDetails();
                BeanUtils.copyProperties(bigStorageDTO, cageDetails);
                BeanUtils.copyProperties(info, cageDetails);
                cageDetails.setSlot(THROUGH_SLOT);
                cageDetails.setState(Const.GLASS_STATE_NEW);
                cageDetails.setDeviceId(0);
                cageDetails.setSequence(0);
                cageDetails.setHollowSequence(0);
                cageDetails.setSequence(bigStorageDTO.getSlotSequence());
                cageDetails.setGap(glassGap);
                cageDetails.setFilmsId(info.getFilmsid());
                cageDetails.setId(null);
                hollowBigStorageCageDetailsService.save(cageDetails);
                hollowGlassRelationInfoService.update(new LambdaUpdateWrapper<HollowGlassRelationInfo>()
                        .set(HollowGlassRelationInfo::getGlassId, cageDetails.getGlassId())
                        .set(HollowGlassRelationInfo::getTemperingLayoutId, cageDetails.getTemperingLayoutId())
                        .set(HollowGlassRelationInfo::getTemperingFeedSequence, cageDetails.getTemperingFeedSequence())
                        .set(HollowGlassRelationInfo::getEngineerId, cageDetails.getEngineerId())
                        .set(HollowGlassRelationInfo::getState, Const.HOLLOW_RELATION_OCCUPY)
                        .eq(HollowGlassRelationInfo::getFlowCardId, bigStorageDTO.getFlowCardId())
                        .eq(HollowGlassRelationInfo::getLayer, bigStorageDTO.getLayer())
                        .eq(HollowGlassRelationInfo::getVirtualSlot, bigStorageDTO.getVirtualSlot())
                        .eq(HollowGlassRelationInfo::getSlotSequence, bigStorageDTO.getSlotSequence())
                        .eq(HollowGlassRelationInfo::getHollowSequence, bigStorageDTO.getHollowSequence())
                );
            }
        } catch (Exception exception) {
            log.info("进片任务执行中发生异常：{}", exception);
            hollowBigStorageCageDetailsService.update(new LambdaUpdateWrapper<HollowBigStorageCageDetails>()
                    .set(HollowBigStorageCageDetails::getState, Const.GLASS_STATE_TAKE)
                    .eq(HollowBigStorageCageDetails::getState, Const.GLASS_STATE_NEW));

            hollowGlassRelationInfoService.update(new LambdaUpdateWrapper<HollowGlassRelationInfo>()
                    .set(HollowGlassRelationInfo::getGlassId, null)
                    .set(HollowGlassRelationInfo::getTemperingLayoutId, null)
                    .set(HollowGlassRelationInfo::getTemperingFeedSequence, null)
                    .set(HollowGlassRelationInfo::getEngineerId, null)
                    .set(HollowGlassRelationInfo::getState, Const.HOLLOW_RELATION_NEW)
                    .eq(HollowGlassRelationInfo::getState, Const.HOLLOW_RELATION_OCCUPY)
            );
            //将格子尺寸恢复
            hollowBigStorageCageService.resetCage();
            return;
        } else {
            BigStorageCageTask task = inTaskList.get(0);
            task.setTargetSlot(THROUGH_SLOT);
            //存放历史任务
            HollowBigStorageCageHistoryTask historyTask = new HollowBigStorageCageHistoryTask();
            BeanUtils.copyProperties(task, historyTask);
            historyTask.setTaskType(Const.BIG_STORAGE_AFTER_IN);
            historyTask.setGlassCount(glassInfoList.size());
            historyTask.setTaskState(Const.ENGINEERING_NEW);
            historyTasks.add(historyTask);
            GlassInfo info = glassInfoList.get(0);
            HollowBigStorageCageDetails cageDetails = new HollowBigStorageCageDetails();
            BeanUtils.copyProperties(info, cageDetails);
            cageDetails.setSlot(THROUGH_SLOT);
            cageDetails.setState(Const.GLASS_STATE_NEW);
            cageDetails.setDeviceId(0);
            cageDetails.setSequence(0);
            cageDetails.setHollowSequence(0);
            cageDetails.setGap(glassGap);
            cageDetails.setFilmsId(info.getFilmsid());
            cageDetails.setId(null);
            hollowBigStorageCageDetailsService.save(cageDetails);
        }

        //历史数据入库
        hollowBigStorageCageHistoryTaskService.saveBatch(historyTasks);
        //向opc发送启动信号
@@ -375,14 +427,14 @@
            return;
        }
        //获取所有空闲的线路信息
        List<Integer> freeLineList = new ArrayList<>();
        HashMap<Integer, Boolean> map = new HashMap<>();
        //获取空闲且领取任务的数据信息，没有任务直接走玻璃调度
        try {
            if (CMJ1ModbusTcp.checkConnected()) {
                Boolean oneState = CMJ1ModbusTcp.readUInt16(42027 - 40001) != 0;
                if (oneState) {
                    freeLineList.add(930);
                }
                map.put(930, oneState);
            } else {
                map.put(930, Boolean.FALSE);
            }
        } catch (Exception e) {
            //nothing
@@ -391,34 +443,51 @@
        try {
            S7DataZKExtra s7DataZKExtra = s7SerializerZKQ2.read(S7DataZKExtra.class);
            log.info("中空额外读取{}", s7DataZKExtra);
            Boolean twoState = s7DataZKExtra.getIsFree();
            Boolean threeState = s7DataZKExtra.getIsFree03();
            if (twoState) {
                freeLineList.add(931);
            }
            if (threeState) {
                freeLineList.add(932);
            }
            map.put(931, s7DataZKExtra.getIsFree());
            map.put(932, s7DataZKExtra.getIsFree03());
        } catch (Exception e) {
            //nothing
            log.info("二/三线线空闲状态获取异常");
        }
        HollowGlassOutRelationInfo hollowGlassOutRelationInfo = null;
        if (CollectionUtil.isNotEmpty(freeLineList)) {
            hollowGlassOutRelationInfo = hollowGlassOutRelationInfoService
                    .getOne(new LambdaQueryWrapper<HollowGlassOutRelationInfo>()
                            .in(HollowGlassOutRelationInfo::getCell, freeLineList)
                            .eq(HollowGlassOutRelationInfo::getState, Const.HOLLOW_FLOW_CARD_START)
                            .orderByAsc(HollowGlassOutRelationInfo::getUpdateTime).last("limit 1")
                    );
        List<Integer> resultList = new ArrayList<>();
        if (redisUtil.getCacheObject("priorityHollowSwitch")) {
            resultList = TWO_LINE_FIRST;
        } else {
            resultList = ONE_LINE_FIRST;
        }

        if (hollowGlassOutRelationInfo == null) {
            hollowGlassOutRelationInfo = hollowGlassOutRelationInfoService
                    .getOne(new LambdaQueryWrapper<HollowGlassOutRelationInfo>()
                            .eq(HollowGlassOutRelationInfo::getState, Const.HOLLOW_FLOW_CARD_START)
                            .orderByAsc(HollowGlassOutRelationInfo::getUpdateTime).last("limit 1")
                    );
        HollowGlassOutRelationInfo hollowGlassOutRelationInfo = null;
        int cell = -1;
        for (Integer i : resultList) {
            if (null == hollowGlassOutRelationInfo) {
                Boolean entity = map.get(i);
                cell = i;
                if (null != entity && entity) {
                    hollowGlassOutRelationInfo = hollowGlassOutRelationInfoService
                            .getOne(new LambdaQueryWrapper<HollowGlassOutRelationInfo>()
                                    .eq(HollowGlassOutRelationInfo::getCell, cell)
                                    .eq(HollowGlassOutRelationInfo::getState, Const.HOLLOW_FLOW_CARD_START)
                                    .orderByAsc(HollowGlassOutRelationInfo::getId)
                                    .last("limit 1")
                            );
                }
            } else {
                break;
            }
        }
        for (Integer i : resultList) {
            if (null == hollowGlassOutRelationInfo) {
                cell = i;
                hollowGlassOutRelationInfo = hollowGlassOutRelationInfoService
                        .getOne(new LambdaQueryWrapper<HollowGlassOutRelationInfo>()
                                .eq(HollowGlassOutRelationInfo::getCell, cell)
                                .eq(HollowGlassOutRelationInfo::getState, Const.HOLLOW_FLOW_CARD_START)
                                .orderByAsc(HollowGlassOutRelationInfo::getId)
                                .last("limit 1")
                        );
            } else {
                break;
            }
        }

        if (null != hollowGlassOutRelationInfo) {
@@ -643,137 +712,144 @@

    @Scheduled(fixedDelay = 1000)
    public void finishOutBigStorageTask() throws Exception {
        S7DataZKDLPTwo s7DataZKDLPTwo = s7SerializerZKDLPTwo.read(S7DataZKDLPTwo.class);
        Boolean inkageEntity = s7DataZKDLPTwo.getMesControl();
        if (true != inkageEntity) {
            log.info("当前为非联机状态，结束完成出片任务");
            return;
        }
        //获取出片任务表
        List<BigStorageCageTask> outTaskList = getOutTaskList(s7DataZKDLPTwo);
        if (CollectionUtil.isEmpty(outTaskList)) {
            log.info("当前大车无出片玻璃，结束完成出片任务");
            return;
        }
        List<BigStorageCageTask> unFinishTaskList = outTaskList.stream().filter(e -> e.getTaskState() <= 1 || e.getStartSlot() == 0).collect(Collectors.toList());
        if (CollectionUtil.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_AFTER_OUT;
        } else {
            taskType = Const.BIG_STORAGE_AFTER_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_AFTER_OUT)) {
                    outSuccessGlassSlot = v.stream().map(BigStorageCageTask::getStartSlot).collect(Collectors.toList());
                } else {
                    List<Integer> targetSuccessGlassSlot = v.stream().map(BigStorageCageTask::getTargetSlot).collect(Collectors.toList());
                    List<Integer> startoutSuccessGlassSlot = v.stream().map(BigStorageCageTask::getStartSlot).collect(Collectors.toList());
                    outSuccessGlassSlot.addAll(targetSuccessGlassSlot);
                    outSuccessGlassSlot.addAll(startoutSuccessGlassSlot);
                }
                List<UpdateHollowBigStorageCageDTO> storageCageDTOList = v.stream().map(e -> {
                    UpdateHollowBigStorageCageDTO storageCageDTO = new UpdateHollowBigStorageCageDTO();
                    storageCageDTO.setGlassId(e.getGlassId());
                    if (finalTaskType.equals(Const.BIG_STORAGE_AFTER_OUT)) {
                        storageCageDTO.setTargetSlot(e.getStartSlot());
                    } else {
                        storageCageDTO.setTargetSlot(e.getTargetSlot());
                    }
                    return storageCageDTO;
                }).collect(Collectors.toList());
                if (finalTaskType.equals(Const.BIG_STORAGE_AFTER_OUT)) {
                    hollowBigStorageCageDetailsService.updateBySlot(storageCageDTOList, Const.GLASS_STATE_OUT);
                } else {
                    hollowBigStorageCageDetailsService.updateBySlot(storageCageDTOList, Const.GLASS_STATE_IN);
                    //按照格子信息更新对应的设备id
                    List<Integer> slotList = storageCageDTOList.stream().map(UpdateHollowBigStorageCageDTO::getTargetSlot).distinct().collect(Collectors.toList());
                    hollowBigStorageCageDetailsService.updateDeviceIdBySlot(slotList);
                }
                log.info("4、大理片笼出片状态已完成已完成的玻璃信息id:{}", v);
                updateSlotRemainBySlots(outSuccessGlassSlot);
            } else if (e1 == 3) {
                //破损处理
                dealDamageOutTask(v);
            } else {
                //清空理片笼空数据
                noDealOutTask(v);
            }
        });

        for (BigStorageCageTask item : outTaskList) {
            //更新历史任务表中的任务状态
            hollowBigStorageCageHistoryTaskService.update(new LambdaUpdateWrapper<HollowBigStorageCageHistoryTask>()
                    .set(HollowBigStorageCageHistoryTask::getTaskState, item.getTaskState())
                    .eq(HollowBigStorageCageHistoryTask::getTaskType, taskType)
                    .eq(HollowBigStorageCageHistoryTask::getGlassId, item.getGlassId()));
            //更新中空小片表
            Integer taskState = item.getTaskState();
            if (taskState == 2) {
                hollowGlassQueueInfoService.update(new LambdaUpdateWrapper<HollowGlassQueueInfo>()
                        .set(HollowGlassQueueInfo::getState, Const.TEMPERING_OUT).eq(HollowGlassQueueInfo::getGlassId, item.getGlassId()));
            } else if (taskState == 3) {
//                temperingGlassInfoService.remove(new LambdaQueryWrapper<TemperingGlassInfo>().eq(TemperingGlassInfo::getGlassId, item.getGlassId()));
                hollowGlassQueueInfoService.update(new LambdaUpdateWrapper<HollowGlassQueueInfo>()
                        .set(HollowGlassQueueInfo::getState, Const.TEMPERING_DAMAGE).eq(HollowGlassQueueInfo::getGlassId, item.getGlassId()));

            } else {
//                空执行
            }
        }
        try {
            //更新数量
            //按照玻璃id获取需要出片对列表中的数据
            if (finalTaskType.equals(Const.BIG_STORAGE_AFTER_OUT)) {
                HollowGlassQueueInfo hollowGlassQueueInfo = hollowGlassQueueInfoService.getOne(new LambdaQueryWrapper<HollowGlassQueueInfo>()
                        .eq(HollowGlassQueueInfo::getGlassId, outTaskList.get(0).getGlassId())
                        .orderByDesc(HollowGlassQueueInfo::getUpdateTime).last("limit 1"));
                List<HollowGlassQueueInfo> list = hollowGlassQueueInfoService.list(new LambdaQueryWrapper<HollowGlassQueueInfo>()
                                .eq(HollowGlassQueueInfo::getFlowCardId, hollowGlassQueueInfo.getFlowCardId())
                                .eq(HollowGlassQueueInfo::getCell, hollowGlassQueueInfo.getCell())
//                        .eq(HollowGlassQueueInfo::getIsPair, 1)
                                .eq(HollowGlassQueueInfo::getState, Const.TEMPERING_NEW)
                );
                if (CollectionUtil.isEmpty(list)) {
//                任务更新为已完成
                    hollowGlassOutRelationInfoService.update(new UpdateWrapper<HollowGlassOutRelationInfo>()
                            .eq("flow_card_id", hollowGlassQueueInfo.getFlowCardId())
                            .eq("cell", hollowGlassQueueInfo.getCell())
                            .setSql("pair_quantity = total_pair_quantity")
                            .set("state", Const.HOLLOW_FLOW_CARD_SUCCESS)
                    );
            S7DataZKDLPTwo s7DataZKDLPTwo = s7SerializerZKDLPTwo.read(S7DataZKDLPTwo.class);
            Boolean inkageEntity = s7DataZKDLPTwo.getMesControl();
            if (true != inkageEntity) {
                log.info("当前为非联机状态，结束完成出片任务");
                return;
            }
            //获取出片任务表
            List<BigStorageCageTask> outTaskList = getOutTaskList(s7DataZKDLPTwo);
            if (CollectionUtil.isEmpty(outTaskList)) {
                log.info("当前大车无出片玻璃，结束完成出片任务");
                return;
            }
            log.info("中空理片笼出片完成任务:{}", outTaskList);
            log.info("中空理片笼出片汇报情况:{}", s7DataZKDLPTwo);
            List<BigStorageCageTask> unFinishTaskList = outTaskList.stream().filter(e -> e.getTaskState() <= 1 || e.getStartSlot() == 0).collect(Collectors.toList());
            if (CollectionUtil.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_AFTER_OUT;
            } else {
                taskType = Const.BIG_STORAGE_AFTER_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_AFTER_OUT)) {
                        outSuccessGlassSlot = v.stream().map(BigStorageCageTask::getStartSlot).collect(Collectors.toList());
                    } else {
                        List<Integer> targetSuccessGlassSlot = v.stream().map(BigStorageCageTask::getTargetSlot).collect(Collectors.toList());
                        List<Integer> startoutSuccessGlassSlot = v.stream().map(BigStorageCageTask::getStartSlot).collect(Collectors.toList());
                        outSuccessGlassSlot.addAll(targetSuccessGlassSlot);
                        outSuccessGlassSlot.addAll(startoutSuccessGlassSlot);
                    }
                    List<UpdateHollowBigStorageCageDTO> storageCageDTOList = v.stream().map(e -> {
                        UpdateHollowBigStorageCageDTO storageCageDTO = new UpdateHollowBigStorageCageDTO();
                        storageCageDTO.setGlassId(e.getGlassId());
                        if (finalTaskType.equals(Const.BIG_STORAGE_AFTER_OUT)) {
                            storageCageDTO.setTargetSlot(e.getStartSlot());
                        } else {
                            storageCageDTO.setTargetSlot(e.getTargetSlot());
                        }
                        return storageCageDTO;
                    }).collect(Collectors.toList());
                    if (finalTaskType.equals(Const.BIG_STORAGE_AFTER_OUT)) {
                        hollowBigStorageCageDetailsService.updateBySlot(storageCageDTOList, Const.GLASS_STATE_OUT);
                    } else {
                        hollowBigStorageCageDetailsService.updateBySlot(storageCageDTOList, Const.GLASS_STATE_IN);
                        //按照格子信息更新对应的设备id
                        List<Integer> slotList = storageCageDTOList.stream().map(UpdateHollowBigStorageCageDTO::getTargetSlot).distinct().collect(Collectors.toList());
                        hollowBigStorageCageDetailsService.updateDeviceIdBySlot(slotList);
                    }
                    log.info("4、大理片笼出片状态已完成已完成的玻璃信息id:{}", v);
                    updateSlotRemainBySlots(outSuccessGlassSlot);
                } else if (e1 == 3) {
                    //破损处理
                    dealDamageOutTask(v);
                } else {
//               计算剩余玻璃对数，用任务总队数减剩余对数
                    int remainCount = list.size() / hollowGlassQueueInfo.getTotalLayer();
                    hollowGlassOutRelationInfoService.update(new UpdateWrapper<HollowGlassOutRelationInfo>()
                            .eq("flow_card_id", hollowGlassQueueInfo.getFlowCardId())
                            .eq("cell", hollowGlassQueueInfo.getCell())
                            .setSql("pair_quantity = total_pair_quantity -" + remainCount)
                    );
                    //清空理片笼空数据
                    noDealOutTask(v);
                }
            });

            for (BigStorageCageTask item : outTaskList) {
                //更新历史任务表中的任务状态
                hollowBigStorageCageHistoryTaskService.update(new LambdaUpdateWrapper<HollowBigStorageCageHistoryTask>()
                        .set(HollowBigStorageCageHistoryTask::getTaskState, item.getTaskState())
                        .eq(HollowBigStorageCageHistoryTask::getTaskType, taskType)
                        .eq(HollowBigStorageCageHistoryTask::getGlassId, item.getGlassId()));
                //更新中空小片表
                Integer taskState = item.getTaskState();
                if (taskState == 2) {
                    hollowGlassQueueInfoService.update(new LambdaUpdateWrapper<HollowGlassQueueInfo>()
                            .set(HollowGlassQueueInfo::getState, Const.TEMPERING_OUT).eq(HollowGlassQueueInfo::getGlassId, item.getGlassId()));
                } else if (taskState == 3) {
//                temperingGlassInfoService.remove(new LambdaQueryWrapper<TemperingGlassInfo>().eq(TemperingGlassInfo::getGlassId, item.getGlassId()));
                    hollowGlassQueueInfoService.update(new LambdaUpdateWrapper<HollowGlassQueueInfo>()
                            .set(HollowGlassQueueInfo::getState, Const.TEMPERING_DAMAGE).eq(HollowGlassQueueInfo::getGlassId, item.getGlassId()));

                } else {
//                空执行
                }
            }
        } catch (Exception e) {
            log.info("计算玻璃数量过程中出现错误，错误信息{}", e.getMessage());
        }
            try {
                //更新数量
                //按照玻璃id获取需要出片对列表中的数据
                if (finalTaskType.equals(Const.BIG_STORAGE_AFTER_OUT)) {
                    HollowGlassQueueInfo hollowGlassQueueInfo = hollowGlassQueueInfoService.getOne(new LambdaQueryWrapper<HollowGlassQueueInfo>()
                            .eq(HollowGlassQueueInfo::getGlassId, outTaskList.get(0).getGlassId())
                            .orderByDesc(HollowGlassQueueInfo::getUpdateTime).last("limit 1"));
                    List<HollowGlassQueueInfo> list = hollowGlassQueueInfoService.list(new LambdaQueryWrapper<HollowGlassQueueInfo>()
                                    .eq(HollowGlassQueueInfo::getFlowCardId, hollowGlassQueueInfo.getFlowCardId())
                                    .eq(HollowGlassQueueInfo::getCell, hollowGlassQueueInfo.getCell())
//                        .eq(HollowGlassQueueInfo::getIsPair, 1)
                                    .eq(HollowGlassQueueInfo::getState, Const.TEMPERING_NEW)
                    );
                    if (CollectionUtil.isEmpty(list)) {
//                任务更新为已完成
                        hollowGlassOutRelationInfoService.update(new UpdateWrapper<HollowGlassOutRelationInfo>()
                                .eq("flow_card_id", hollowGlassQueueInfo.getFlowCardId())
                                .eq("cell", hollowGlassQueueInfo.getCell())
                                .setSql("pair_quantity = total_pair_quantity")
                                .set("state", Const.HOLLOW_FLOW_CARD_SUCCESS)
                        );
                    } else {
//               计算剩余玻璃对数，用任务总队数减剩余对数
                        int remainCount = list.size() / hollowGlassQueueInfo.getTotalLayer();
                        hollowGlassOutRelationInfoService.update(new UpdateWrapper<HollowGlassOutRelationInfo>()
                                .eq("flow_card_id", hollowGlassQueueInfo.getFlowCardId())
                                .eq("cell", hollowGlassQueueInfo.getCell())
                                .setSql("pair_quantity = total_pair_quantity -" + remainCount)
                        );
                    }
                }
            } catch (Exception e) {
                log.info("计算玻璃数量过程中出现错误，错误信息{}", e.getMessage());
            }

//       重置任务表数据
        resetOutTask();
        //清空启动状态
        //向opc发送启动信号
        s7DataZKDLPTwo = new S7DataZKDLPTwo();
        s7DataZKDLPTwo.setMesReply(0);
        s7SerializerZKDLPTwo.write(s7DataZKDLPTwo);
            resetOutTask();
            //清空启动状态
            //向opc发送启动信号
            s7DataZKDLPTwo = new S7DataZKDLPTwo();
            s7DataZKDLPTwo.setMesReply(0);
            s7SerializerZKDLPTwo.write(s7DataZKDLPTwo);
        } catch (Exception e) {
            log.info("中空理片笼出片汇报任务异常：{}", e);
        }

    }

    private void dealDamageInTask(List<BigStorageCageTask> damageTaskList) {
@@ -853,7 +929,7 @@
            List<String> glassList = noDealTaskList.stream().map(BigStorageCageTask::getGlassId).collect(Collectors.toList());
            hollowBigStorageCageDetailsService.update(new LambdaUpdateWrapper<HollowBigStorageCageDetails>()
                    .set(HollowBigStorageCageDetails::getState, Const.GLASS_STATE_IN)
                    .ne(HollowBigStorageCageDetails::getState, Const.GLASS_STATE_OUT)
                    .notIn(HollowBigStorageCageDetails::getState, Const.GLASS_STATE_OUT, Const.GLASS_STATE_DAMAGE, Const.GLASS_STATE_TAKE)
                    .in(HollowBigStorageCageDetails::getGlassId, glassList));

        } else {
@@ -862,7 +938,7 @@
                hollowBigStorageCageDetailsService.update(new LambdaUpdateWrapper<HollowBigStorageCageDetails>()
                        .set(HollowBigStorageCageDetails::getSlot, item.getStartSlot())
                        .set(HollowBigStorageCageDetails::getState, Const.GLASS_STATE_IN)
                        .ne(HollowBigStorageCageDetails::getState, Const.GLASS_STATE_OUT)
                        .notIn(HollowBigStorageCageDetails::getState, Const.GLASS_STATE_OUT, Const.GLASS_STATE_DAMAGE, Const.GLASS_STATE_TAKE)
                        .eq(HollowBigStorageCageDetails::getGlassId, item.getGlassId()));
            }
        }
@@ -972,10 +1048,19 @@
                    }
                    baseInfoList = resultList;
                } else {
                    //大于总层数先取totalLyaer倍数数量的玻璃，保证大车上的玻璃成对传
                    //大于总层数先取totalLayer倍数数量的玻璃，保证大车上的玻璃成对传
                    int remainCount = templist.size() % totalLayer;
                    if (targetSlot == 930) {
                        baseInfoList = templist.subList(0, totalLayer);
                        int tempSequence = templist.get(0).getHollowSequence();
                        List<T> resultList = new ArrayList<>();
                        for (int i = 0; i < templist.size(); i++) {
                            if (tempSequence == list.get(i).getHollowSequence()) {
                                resultList.add(templist.get(i));
                            } else {
                                break;
                            }
                        }
                        baseInfoList = resultList;
                    } else {
                        baseInfoList = templist.subList(0, templist.size() - remainCount);
                    }
@@ -1049,7 +1134,7 @@
        hollowBigStorageCageDetailsService.update(new LambdaUpdateWrapper<HollowBigStorageCageDetails>()
                .set(HollowBigStorageCageDetails::getState, state)
                .set(Const.BIG_STORAGE_AFTER_DISPATCH.equals(taskType), HollowBigStorageCageDetails::getSlot, targetSlot)
                .ne(HollowBigStorageCageDetails::getState, Const.GLASS_STATE_OUT)
                .notIn(HollowBigStorageCageDetails::getState, Const.GLASS_STATE_OUT, Const.GLASS_STATE_DAMAGE, Const.GLASS_STATE_TAKE)
                .in(HollowBigStorageCageDetails::getGlassId, glassIds));
        try {
            s7DataZKDLPTwo = new S7DataZKDLPTwo();