1、 中空理片笼任务优化：进片调度任务添加日志

zhoushihao

2025-10-30 942eb631e1c6bef5f9d8dfd6f2c7e2ad669ca80d

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

@@ -115,7 +115,8 @@

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

    /**
     * 直通格子
@@ -131,8 +132,7 @@
        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)
                .eq(ProductAlarmInfo::getAlarmCode, ALARM_CODE));
                .eq(ProductAlarmInfo::getAlarmType, ALARM_TYPE));
        if (CollectionUtil.isNotEmpty(alarmInfos)) {
            log.info("界面报警，等待人工干预处理");
            return;
@@ -157,14 +157,17 @@

        List<BigStorageCageTask> inTaskList = new ArrayList();
        Integer from = s7DataZKDLPOne.getFrom1();
        List<Integer> states = s7DataZKDLPOne.getStates();
        List<String> glassIdList = new ArrayList<>();
        List<String> requestWords = s7DataZKDLPOne.getIds();
        for (int i = 1; i <= 6; i++) {
            String requestWord = requestWords.get(i - 1);
            Integer state = states.get(i - 1);
            if (null != requestWord && !requestWord.isEmpty()) {
                BigStorageCageTask task = new BigStorageCageTask();
                task.setGlassId(requestWord);
                task.setStartSlot(from);
                task.setTaskState(state);
                inTaskList.add(task);
                glassIdList.add(requestWord);
                continue;
@@ -174,11 +177,24 @@
            log.info("当前大车无进片玻璃，结束进片任务");
            return;
        }
        //玻璃状态存在卧转立上结束
        List<BigStorageCageTask> unTaskList = inTaskList.stream().filter(e -> e.getTaskState() < 1).collect(Collectors.toList());
        if (CollectionUtil.isNotEmpty(unTaskList)) {
            log.info("存在未上车的玻璃信息,玻璃：{}", unTaskList);
            return;
        }
        log.info("获取任务的玻璃id：{}", glassIdList);
        Map<String, Long> glassCountMap = glassIdList.stream().collect(Collectors.groupingBy(e -> e, Collectors.counting()));
        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);
@@ -191,6 +207,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);
@@ -211,38 +237,38 @@
        Integer slotMaxThickness = sysConfigService.queryConfigValue(ConstSysConfig.HOLLOW_SLOT_MAX_THICKNESS);
        //按照玻璃厚度分组，判断剩余格子是否可以存放
        Map<Double, Long> thickCountMap = glassInfoList.stream().collect(Collectors.groupingBy(GlassInfo::getThickness, Collectors.counting()));
        if (glassInfoList.get(0).getThickness() < slotMaxThickness) {
            for (Map.Entry<Double, Long> entry : thickCountMap.entrySet()) {
                int count = hollowBigStorageCageService.count(new LambdaQueryWrapper<HollowBigStorageCage>()
                        .eq(HollowBigStorageCage::getEnableState, Const.SLOT_ON).eq(HollowBigStorageCage::getRemainWidth, slotWidth)
                        .le(HollowBigStorageCage::getMinThickness, entry.getKey())
                        .ge(HollowBigStorageCage::getMaxThickness, entry.getKey()));
                if (count < entry.getValue()) {
                    log.info("笼内格子剩余数量不足，结束本次进片");
                    //向plc发送报警:笼内格子剩余数量不足
                    s7DataZKDLPOne = new S7DataZKDLPOne();
                    s7DataZKDLPOne.setAlramSignal(16);
                    s7SerializerZKDLPOne.write(s7DataZKDLPOne);
                    return;
                }
            }
        }
        //超大尺寸
        Integer slotMaxHeight = sysConfigService.queryConfigValue(ConstSysConfig.HOLLOW_SLOT_MAX_HEIGHT);
        Integer slotMaxthickness = sysConfigService.queryConfigValue(ConstSysConfig.HOLLOW_SLOT_MAX_THICKNESS);
        if (slotMaxHeight < Math.min(glassInfoList.get(0).getWidth(), glassInfoList.get(0).getHeight()) || glassInfoList.get(0).getThickness() >= slotMaxthickness) {
            int count = hollowBigStorageCageDetailsService.count(new LambdaQueryWrapper<HollowBigStorageCageDetails>()
                    .eq(HollowBigStorageCageDetails::getSlot, THROUGH_SLOT)
                    .in(HollowBigStorageCageDetails::getState, Const.GLASS_STATE_IN_ALL));
            if (count > 0) {
                log.info("直通片台存在玻璃，结束本次进片");
                //向plc发送报警:直通片台存在玻璃，无法继续直通
//        if (glassInfoList.get(0).getThickness() < slotMaxThickness) {
        for (Map.Entry<Double, Long> entry : thickCountMap.entrySet()) {
            int count = hollowBigStorageCageService.count(new LambdaQueryWrapper<HollowBigStorageCage>()
                    .eq(HollowBigStorageCage::getEnableState, Const.SLOT_ON).eq(HollowBigStorageCage::getRemainWidth, slotWidth)
                    .le(HollowBigStorageCage::getMinThickness, entry.getKey())
                    .ge(HollowBigStorageCage::getMaxThickness, entry.getKey()));
            if (count < entry.getValue()) {
                log.info("笼内格子剩余数量不足，结束本次进片");
                //向plc发送报警:笼内格子剩余数量不足
                s7DataZKDLPOne = new S7DataZKDLPOne();
                s7DataZKDLPOne.setAlramSignal(64);
                s7DataZKDLPOne.setAlramSignal(16);
                s7SerializerZKDLPOne.write(s7DataZKDLPOne);
                return;
            }
        }
//        }
        //超大尺寸
//        Integer slotMaxHeight = sysConfigService.queryConfigValue(ConstSysConfig.HOLLOW_SLOT_MAX_HEIGHT);
//        Integer slotMaxthickness = sysConfigService.queryConfigValue(ConstSysConfig.HOLLOW_SLOT_MAX_THICKNESS);
//        if (slotMaxHeight < Math.min(glassInfoList.get(0).getWidth(), glassInfoList.get(0).getHeight()) || glassInfoList.get(0).getThickness() >= slotMaxthickness) {
//            int count = hollowBigStorageCageDetailsService.count(new LambdaQueryWrapper<HollowBigStorageCageDetails>()
//                    .eq(HollowBigStorageCageDetails::getSlot, THROUGH_SLOT)
//                    .in(HollowBigStorageCageDetails::getState, Const.GLASS_STATE_IN_ALL));
//            if (count > 0) {
//                log.info("直通片台存在玻璃，结束本次进片");
//                //向plc发送报警:直通片台存在玻璃，无法继续直通
//                s7DataZKDLPOne = new S7DataZKDLPOne();
//                s7DataZKDLPOne.setAlramSignal(64);
//                s7SerializerZKDLPOne.write(s7DataZKDLPOne);
//                return;
//            }
//        }

        log.info("将钢化小片表内的状态改为钢化结束，玻璃id有：{}", glassIdList);
        //修改钢化任务表中的状态
@@ -261,8 +287,9 @@
        Integer glassGap = sysConfigService.queryConfigValue(ConstSysConfig.HOLLOW_GLASS_GAP);

        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) {
//        if (slotMaxHeight > Math.min(glassInfoList.get(0).getWidth(), glassInfoList.get(0).getHeight()) && glassInfoList.get(0).getThickness() < slotMaxthickness) {
        for (BigStorageCageTask task : inTaskList) {
            if (from == 910) {
                GlassInfo info = glassListMap.get(task.getGlassId()).get(0);
                HollowBigStorageDTO bigStorageDTO = null;
                try {
@@ -275,7 +302,7 @@
                    alarmInfo.setState(Const.LOAD_RAW_GLASS_NEW);
                    alarmInfo.setAlarmModule(ALARM_MODULE);
                    alarmInfo.setAlarmType(ALARM_TYPE);
                    alarmInfo.setAlarmCode(ALARM_CODE);
                    alarmInfo.setAlarmCode(ALARM_CODE_SIZE);
                    alarmInfo.setAlarmMessage(info.getGlassId());
                    productAlarmInfoService.save(alarmInfo);
                    //重置详情表数据
@@ -330,29 +357,29 @@
                        .eq(HollowGlassRelationInfo::getSlotSequence, bigStorageDTO.getSlotSequence())
                        .eq(HollowGlassRelationInfo::getHollowSequence, bigStorageDTO.getHollowSequence())
                );

            } else {
                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);
            }
        } 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);
        }

        //历史数据入库
@@ -432,6 +459,7 @@
            //nothing
            log.info("二/三线线空闲状态获取异常");
        }

        List<Integer> resultList = new ArrayList<>();
        if (redisUtil.getCacheObject("priorityHollowSwitch")) {
            resultList = TWO_LINE_FIRST;
@@ -478,14 +506,29 @@
            //是否有正在中空的玻璃:中空小片表筛选未出笼的玻璃信息
//            获取当前中空任务未完成出片的玻璃信息
            List<HollowGlassQueueInfo> unFinishHollowQueueList = hollowGlassQueueInfoService.list(new LambdaQueryWrapper<HollowGlassQueueInfo>()
                    .eq(HollowGlassQueueInfo::getFlowCardId, hollowGlassOutRelationInfo.getFlowCardId())
                    .eq(HollowGlassQueueInfo::getCell, hollowGlassOutRelationInfo.getCell())
                    .eq(HollowGlassQueueInfo::getState, Const.TEMPERING_NEW)
                    .eq(HollowGlassQueueInfo::getRelationId, hollowGlassOutRelationInfo.getId())
                    .orderByAsc(HollowGlassQueueInfo::getHollowSequence));
            if (CollectionUtil.isNotEmpty(unFinishHollowQueueList)) {
                //直通台有玻璃时将中空出片队列中对应玻璃id的格子号替换未直通台
                HollowBigStorageCageDetails details = hollowBigStorageCageDetailsService.getOne(new LambdaQueryWrapper<HollowBigStorageCageDetails>()
                        .eq(HollowBigStorageCageDetails::getSlot, THROUGH_SLOT)
                        .in(HollowBigStorageCageDetails::getState, Const.GLASS_STATE_IN_ALL).last("limit 1"));
                log.info("中空大理片直通台玻璃信息{}", details);
                if (details != null) {
                    unFinishHollowQueueList.stream().forEach(e -> {
                        if (e.getGlassId().equals(details.getGlassId())) {
                            e.setSlot(THROUGH_SLOT);
                            e.setDeviceId(0);
                            log.info("将中空队列中的格子号替换为直通台{}", e);
                        }
                    });
                }

                List<HollowGlassQueueInfo> infoList = unFinishHollowQueueList.stream().filter(e -> !(e.getSlot() > 500 && e.getSlot() < 900 && e.getIsPair() != 1)).collect(Collectors.toList());
                log.info("有正在出片的中空任务");
                Integer isPair = unFinishHollowQueueList.get(0).getIsPair();
                hollowOutGlassByIsPair(unFinishHollowQueueList, hollowGlassOutRelationInfo.getCell(), isPair, hollowGlassOutRelationInfo.getTotalLayer(), hollowGlassOutRelationInfo.getIsForce());
                Integer isPair = infoList.get(0).getIsPair();
                hollowOutGlassByIsPair(infoList, hollowGlassOutRelationInfo.getCell(), isPair, hollowGlassOutRelationInfo.getTotalLayer(), hollowGlassOutRelationInfo.getIsForce());
                Date endDate = new Date();
                log.info("大理片笼出片任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime());
                return;
@@ -695,138 +738,210 @@

    @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);
        }

    }

    @Scheduled(fixedDelay = 1000)
    public void inCarTask() {
        //读取协议数据
        S7DataZKDLPOne s7DataZKDLPOne = s7SerializerZKDLPOne.read(S7DataZKDLPOne.class);
        log.info("进片任务读取s7DataZKDLPOne:{}", s7DataZKDLPOne);
        Boolean inkageEntity = s7DataZKDLPOne.getMesControl();
        if (!inkageEntity) {
            log.info("当前为非联机状态，结束进片任务");
            return;
        }
        Integer requestEntity = s7DataZKDLPOne.getRequestMes();
        if (StringUtils.isNotBlank(s7DataZKDLPOne.getId7()) && requestEntity == 0) {
            //汇报字为1 启动字为1是  清除所有任务信息
            if (s7DataZKDLPOne.getId7().equals(s7DataZKDLPOne.getId1())) {
                //todo:清空任务
                S7DataZKDLPOne sendTask = new S7DataZKDLPOne();
                sendTask.setFrom7(0);
                sendTask.setId7("");
                s7SerializerZKDLPOne.write(sendTask);
                log.info("清除所有任务信息{}", sendTask);
                s7DataZKDLPOne = s7SerializerZKDLPOne.read(S7DataZKDLPOne.class);
                log.info("清空任务后再读取{}", s7DataZKDLPOne);
            }
            log.info("存在任务，结束");
            return;
        }
        if (1 != requestEntity) {
            log.info("当前未收到进片请求，结束进片任务");
            return;
        }
        //有请求信号
        List<String> glassIdList = hollowGlassQueueInfoService.queryNeedInCarGlass();
        if (CollectionUtil.isEmpty(glassIdList)) {
            return;
        }
        int count = hollowBigStorageCageDetailsService.count(new LambdaQueryWrapper<HollowBigStorageCageDetails>()
                .eq(HollowBigStorageCageDetails::getState, Const.GLASS_STATE_IN)
                .eq(HollowBigStorageCageDetails::getSlot, THROUGH_SLOT));
        log.info("直通片台的任务数量为：{}", count);
        if (count > 0) {
            return;
        }
        List<HollowBigStorageCageDetails> list = hollowBigStorageCageDetailsService.list(new LambdaQueryWrapper<HollowBigStorageCageDetails>()
                .eq(HollowBigStorageCageDetails::getState, Const.GLASS_STATE_IN)
//                .in(HollowBigStorageCageDetails::getDeviceId, 6)
                .in(HollowBigStorageCageDetails::getGlassId, glassIdList));
        log.info("获取调度任务列表：{}", list);
        if (CollectionUtil.isEmpty(list)) {
            return;
        }
        HollowBigStorageCageDetails details = list.get(0);
        log.info("获取需要调度的单条任务：{}", details);
        //生成进进片大车任务
        hollowBigStorageCageDetailsService.update(new LambdaUpdateWrapper<HollowBigStorageCageDetails>()
                .set(HollowBigStorageCageDetails::getState, Const.RAW_GLASS_STATE_OUT)
                .eq(HollowBigStorageCageDetails::getGlassId, details.getGlassId()));
        S7DataZKDLPOne sendTask = new S7DataZKDLPOne();
        sendTask.setFrom7(details.getSlot());
        sendTask.setId7(details.getGlassId());
        s7SerializerZKDLPOne.write(sendTask);
        log.info("新笼子写入id与from{}", sendTask);
        updateSlotRemainBySlots(Arrays.asList(details.getSlot()));
    }


    private void dealDamageInTask(List<BigStorageCageTask> damageTaskList) {
//        获取进片任务表中状态为破损的数据
@@ -998,6 +1113,7 @@
        Integer outCarMaxSize = sysConfigService.queryConfigValue(ConstSysConfig.HOLLOW_OUT_CAR_SIZE);
//        Integer glassGap = sysConfigService.queryConfigValue(ConstSysConfig.HOLLOW_GLASS_GAP);
        Integer glassGap = hollowGlassRelationInfoService.getGlassGapByThickness(list.get(0).getThickness());
        log.info("中空生成一车任务：{}", list);
        for (T e : list) {
            if (templist.size() >= outCarMaxSize || Math.max((int) e.getWidth(), (int) e.getHeight()) > remainWidth) {
                break;
@@ -1024,10 +1140,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);
                    }
@@ -1041,6 +1166,12 @@
        for (T t : baseInfoList) {
            bigStorageCageTaskList.add(new BigStorageCageTask(t.getGlassId(), t.getSlot(), targetSlot, 0));
        }

        List<BigStorageCageTask> tasks = bigStorageCageTaskList.stream().filter(e -> e.getStartSlot() >= 500 && e.getStartSlot() < 900).collect(Collectors.toList());
        if (CollectionUtil.isNotEmpty(tasks)) {
            log.info("当前出片队列存在新笼子的玻璃小片，结束本次任务：{}", tasks);
            return false;
        }
        //清空任务表数据
        resetOutTask();
        log.info("生成出片任务数据{}", bigStorageCageTaskList);