1、中空领取任务界面查询慢解决 2、卧理新增日志记录

zhoushihao

2025-10-09 266ca8c80300d479351eed50fee5a30751a22fda

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

@@ -6,12 +6,17 @@
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.github.xingshuangs.iot.protocol.modbus.service.ModbusTcp;
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;
import com.mes.common.config.Const;
import com.mes.common.config.ConstSysConfig;
import com.mes.damage.entity.Damage;
import com.mes.damage.service.DamageService;
import com.mes.glassinfo.entity.GlassInfo;
@@ -32,6 +37,10 @@
import com.mes.hollowqueue.service.HollowGlassQueueInfoService;
import com.mes.hollowtask.entity.HollowBigStorageCageHistoryTask;
import com.mes.hollowtask.service.HollowBigStorageCageHistoryTaskService;
import com.mes.s7.entity.S7DataZKDLPOne;
import com.mes.s7.entity.S7DataZKDLPTwo;
import com.mes.s7.entity.S7DataZKExtra;
import com.mes.sysconfig.service.SysConfigService;
import com.mes.temperingglass.entity.TemperingGlassInfo;
import com.mes.temperingglass.service.TemperingGlassInfoService;
import com.mes.utils.RedisUtil;
@@ -39,7 +48,7 @@
import org.apache.commons.lang.StringUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

@@ -75,9 +84,40 @@
    private HollowGlassQueueInfoService hollowGlassQueueInfoService;
    @Resource
    private HollowGlassOutRelationInfoService hollowGlassOutRelationInfoService;
    @Resource
    private SysConfigService sysConfigService;

    @Autowired
    @Qualifier("s7SerializerZKDLPOne")
    private S7Serializer s7SerializerZKDLPOne;

    @Autowired
    @Qualifier("s7SerializerZKDLPTwo")
    private S7Serializer s7SerializerZKDLPTwo;

    @Autowired
    @Qualifier("s7SerializerZKQ2")
    private S7Serializer s7SerializerZKQ2;

    @Autowired
    @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";

    /**
     * 直通格子
     */
@@ -87,52 +127,46 @@
    @Resource
    private RedisUtil redisUtil;

    @Value("${mes.slotWidth}")
    private Integer slotWidth;

    @Value("${mes.glassGap}")
    private Integer glassGap;

    @Value("${mes.carWidth}")
    private Integer carWidth;

    @Value("${mes.outCarMaxSize}")
    private Integer outCarMaxSize;

    @Value("${mes.slotMaxHeight}")
    private Integer slotMaxHeight;
    @Value("${mes.slotMaxthickness}")
    private Integer slotMaxthickness;

    @Scheduled(fixedDelay = 1000)
    public void inBigStorageTask() throws Exception {
        ReadWriteEntity inkageEntity = miloService.readFromOpcUa("DLP2A.DLP2A.mesControl");
        if (true != Boolean.parseBoolean(inkageEntity.getValue() + "")) {
    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();
        if (!inkageEntity) {
            log.info("当前为非联机状态，结束进片任务");
            return;
        }
        ReadWriteEntity requestEntity = miloService.readFromOpcUa("DLP2A.DLP2A.RequestMes");
        if (!"1".equals(requestEntity.getValue() + "")) {
        Integer requestEntity = s7DataZKDLPOne.getRequestMes();
        if (1 != requestEntity) {
            log.info("当前未收到进片请求，结束进片任务");
            return;
        }
        ReadWriteEntity mesReplyEntity = miloService.readFromOpcUa("DLP2A.DLP2A.MesReply");
        if ("1".equals(mesReplyEntity.getValue() + "")) {
        Integer mesReplyEntity = s7DataZKDLPOne.getMesReply();
        if (1 == mesReplyEntity) {
            log.info("有正在执行的任务，结束进片任务");
            return;
        }

        List<BigStorageCageTask> inTaskList = new ArrayList();
        ReadWriteEntity fromOpcUa = miloService.readFromOpcUa("DLP2A.DLP2A.FROM1");
        Integer from = s7DataZKDLPOne.getFrom1();
        List<String> glassIdList = new ArrayList<>();
        List<String> requestWords = s7DataZKDLPOne.getIds();
        for (int i = 1; i <= 6; i++) {
            ReadWriteEntity requestWord = miloService.readFromOpcUa("DLP2A.DLP2A.DI" + i);
            if (null != requestWord.getValue()) {
            String requestWord = requestWords.get(i - 1);
            if (null != requestWord && !requestWord.isEmpty()) {
                BigStorageCageTask task = new BigStorageCageTask();
                task.setGlassId(requestWord.getValue() + "");
                task.setStartSlot(Integer.parseInt(fromOpcUa.getValue() + ""));
                task.setGlassId(requestWord);
                task.setStartSlot(from);
                inTaskList.add(task);
                glassIdList.add(requestWord.getValue() + "");
                glassIdList.add(requestWord);
                continue;
            }
        }
@@ -145,7 +179,17 @@
        for (Map.Entry<String, Long> entry : glassCountMap.entrySet()) {
            if (entry.getValue() > 1) {
                log.info("进片玻璃{}存在相同，结束本次任务", entry.getKey());
                //todo:向plc发送报警
                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);
                s7SerializerZKDLPOne.write(s7DataZKDLPOne);
                return;
            }
        }
@@ -153,37 +197,66 @@
                .in(HollowBigStorageCageDetails::getState, Const.GLASS_STATE_IN_ALL_ZERO));
        if (CollectionUtil.isNotEmpty(detailsList)) {
            log.info("理片笼存在相同的进片玻璃{}，结束本次任务", detailsList);
            //todo:向plc发送报警
            //向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);
            return;
        }
        List<GlassInfo> glassInfoList = glassInfoService.list(new LambdaQueryWrapper<GlassInfo>().in(GlassInfo::getGlassId, glassIdList));

        if (glassInfoList.size() != inTaskList.size()) {
            log.info("进片任务数量{}与玻璃数量{}不匹配，结束本次进片", inTaskList.size(), glassInfoList.size());
            //todo:向plc发送报警
            //向plc发送报警:进片任务数量与系统查询到的玻璃数量不匹配
            s7DataZKDLPOne = new S7DataZKDLPOne();
            s7DataZKDLPOne.setAlramSignal(8);
            s7SerializerZKDLPOne.write(s7DataZKDLPOne);
            return;
        }

        Integer slotWidth = sysConfigService.queryConfigValue(ConstSysConfig.HOLLOW_SLOT_WIDTH);
        Integer slotMaxThickness = sysConfigService.queryConfigValue(ConstSysConfig.HOLLOW_SLOT_MAX_THICKNESS);
        //按照玻璃厚度分组，判断剩余格子是否可以存放
        Map<Double, Long> thickCountMap = glassInfoList.stream().collect(Collectors.groupingBy(GlassInfo::getThickness, Collectors.counting()));
        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("笼内格子剩余数量不足，结束本次进片");
                //todo:向plc发送报警
                return;
        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;
                }
            }
        }
        //todo:超大尺寸
        if (slotMaxHeight < Math.min(glassInfoList.get(0).getWidth(), glassInfoList.get(0).getHeight()) || glassInfoList.get(0).getThickness() > slotMaxthickness) {
        //超大尺寸
        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("直通片台存在玻璃，结束本次进片");
                //todo:向plc发送报警
                //向plc发送报警:直通片台存在玻璃，无法继续直通
                s7DataZKDLPOne = new S7DataZKDLPOne();
                s7DataZKDLPOne.setAlramSignal(64);
                s7SerializerZKDLPOne.write(s7DataZKDLPOne);
                return;
            }
        }
@@ -201,18 +274,51 @@

        //计算目标格子
        List<HollowBigStorageCageHistoryTask> historyTasks = new ArrayList<>();
        try {

        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) {
                GlassInfo info = glassListMap.get(task.getGlassId()).get(0);
                HollowBigStorageDTO bigStorageDTO = hollowGlassRelationInfoService.queryHollowTargetSlot(info.getFlowCardId(),
                        info.getWidth(), info.getHeight(), info.getTotalLayer(), info.getLayer());
                HollowBigStorageDTO bigStorageDTO = null;
                try {
                    bigStorageDTO = hollowGlassRelationInfoService.queryHollowTargetSlot(info.getFlowCardId(), info.getGlassType(),
                            info.getWidth(), info.getHeight(), info.getTotalLayer(), info.getLayer());
                } 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, 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;
                }

//            临时更新格子的剩余尺寸：防止相邻玻璃进同一格子造成剩余尺寸不足，玻璃越界的情况，任务完成后再次更新大理片笼表剩余宽度（按照笼内玻璃数量更新大理片笼剩余尺寸）
                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());
                bigStorageCageTaskService.updateTaskMessage(BIG_STORAGE_CAGE_IN_TWO_TASK, task);
                //存放历史任务
                HollowBigStorageCageHistoryTask historyTask = new HollowBigStorageCageHistoryTask();
                BeanUtils.copyProperties(task, historyTask);
@@ -242,87 +348,146 @@
                        .eq(HollowGlassRelationInfo::getHollowSequence, bigStorageDTO.getHollowSequence())
                );
            }
        } catch (Exception exception) {
            log.info("进片任务执行中发生异常：{}", exception);
            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)
            );
        } 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发送启动信号
        List<ReadWriteEntity> list = new ArrayList<>();
        for (int i = 1; i <= inTaskList.size(); i++) {
            list.add(generateReadWriteEntity("DLP2A.DLP2A.TO" + i, inTaskList.get(i - 1).getTargetSlot()));
        s7DataZKDLPOne = new S7DataZKDLPOne();
        for (int i = 0; i < inTaskList.size() && i < 6; i++) {
            Integer value = inTaskList.get(i).getTargetSlot();
            switch (i) {
                case 0:
                    s7DataZKDLPOne.setTo1(value);
                    break;
                case 1:
                    s7DataZKDLPOne.setTo2(value);
                    break;
                case 2:
                    s7DataZKDLPOne.setTo3(value);
                    break;
                case 3:
                    s7DataZKDLPOne.setTo4(value);
                    break;
                case 4:
                    s7DataZKDLPOne.setTo5(value);
                    break;
                case 5:
                    s7DataZKDLPOne.setTo6(value);
                    break;
            }
        }
        list.add(generateReadWriteEntity("DLP2A.DLP2A.MesReply", 1));
        miloService.writeToOpcWord(list);
        s7SerializerZKDLPOne.write(s7DataZKDLPOne);
        s7DataZKDLPOne = new S7DataZKDLPOne();
        s7DataZKDLPOne.setMesReply(1);
        s7SerializerZKDLPOne.write(s7DataZKDLPOne);
    }

    @Scheduled(fixedDelay = 1000)
    public void outBigStorageTask() throws Exception {
        Date startDate = new Date();
        ReadWriteEntity inkageEntity = miloService.readFromOpcUa("DLP2B.DLP2B.mesControl");
        if (true != Boolean.parseBoolean(inkageEntity.getValue() + "")) {
        S7DataZKDLPTwo s7DataZKDLPTwo = s7SerializerZKDLPTwo.read(S7DataZKDLPTwo.class);
        log.info("出片任务读取s7DataZKDLPTwo:{}", s7DataZKDLPTwo);
        Boolean inkageEntity = s7DataZKDLPTwo.getMesControl();
        if (!inkageEntity) {
            log.info("当前为非联机状态，结束进片任务");
            return;
        }
        ReadWriteEntity requestEntity = miloService.readFromOpcUa("DLP2B.DLP2B.RequestMes");
        if (!"1".equals(requestEntity.getValue() + "")) {
        Integer requestEntity = s7DataZKDLPTwo.getRequestMes();
        if (1 != requestEntity) {
            log.info("当前未收到出片请求，结束出片任务");
            return;
        }
        //获取出片任务表
        List<BigStorageCageTask> outTaskList = bigStorageCageTaskService.queryTaskMessage(BIG_STORAGE_CAGE_OUT_TWO_TASK);
        List<BigStorageCageTask> outTaskList = getOutTaskList(s7DataZKDLPTwo);
        if (CollectionUtil.isNotEmpty(outTaskList)) {
            log.info("有正在执行的出片任务，结束本次出片任务");
            return;
        }

        //获取所有空闲的线路信息
        HashMap<Integer, Boolean> map = new HashMap<>();
        //获取空闲且领取任务的数据信息，没有任务直接走玻璃调度
        ReadWriteEntity oneEntity = miloService.readFromOpcUa("CMJ1.CMJ1.isFree");
        try {
            if (CMJ1ModbusTcp.checkConnected()) {
                Boolean oneState = CMJ1ModbusTcp.readUInt16(42027 - 40001) != 0;
                map.put(930, oneState);
            } else {
                map.put(930, Boolean.FALSE);
            }
        } catch (Exception e) {
            //nothing
            log.info("一线空闲状态获取异常");
        }
        try {
            S7DataZKExtra s7DataZKExtra = s7SerializerZKQ2.read(S7DataZKExtra.class);
            log.info("中空额外读取{}", s7DataZKExtra);
            map.put(931, s7DataZKExtra.getIsFree());
            map.put(932, s7DataZKExtra.getIsFree03());
        } catch (Exception e) {
            //nothing
            log.info("二/三线线空闲状态获取异常");
        }
        List<Integer> resultList = new ArrayList<>();
        if (redisUtil.getCacheObject("priorityHollowSwitch")) {
            resultList = TWO_LINE_FIRST;
        } else {
            resultList = ONE_LINE_FIRST;
        }

        HollowGlassOutRelationInfo hollowGlassOutRelationInfo = null;
        int cell = -1;
        //李赛克线需要获取韩江plc的线路空闲状态：10000000第8位为 1表示忙碌 0表示空闲
        if (null != oneEntity.getValue() && "1".equals(oneEntity.getValue() + "")) {
            cell = 930;
            hollowGlassOutRelationInfo = hollowGlassOutRelationInfoService
                    .getOne(new LambdaQueryWrapper<HollowGlassOutRelationInfo>()
                            .eq(HollowGlassOutRelationInfo::getCell, cell)
                            .eq(HollowGlassOutRelationInfo::getState, Const.HOLLOW_FLOW_CARD_START)
                    );
        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;
            }
        }

        ReadWriteEntity twoEntity = miloService.readFromOpcUa("ZKQ2.ZKQ2.isFree");
        if (null == hollowGlassOutRelationInfo && null != twoEntity.getValue() && Boolean.parseBoolean(twoEntity.getValue() + "")) {
            cell = 931;
            hollowGlassOutRelationInfo = hollowGlassOutRelationInfoService
                    .getOne(new LambdaQueryWrapper<HollowGlassOutRelationInfo>()
                            .eq(HollowGlassOutRelationInfo::getCell, cell)
                            .eq(HollowGlassOutRelationInfo::getState, Const.HOLLOW_FLOW_CARD_START)
                    );
        }
        if (null == hollowGlassOutRelationInfo) {
            cell = 930;
            hollowGlassOutRelationInfo = hollowGlassOutRelationInfoService
                    .getOne(new LambdaQueryWrapper<HollowGlassOutRelationInfo>()
                            .eq(HollowGlassOutRelationInfo::getCell, cell)
                            .eq(HollowGlassOutRelationInfo::getState, Const.HOLLOW_FLOW_CARD_START)
                    );
        }

        if (null == hollowGlassOutRelationInfo) {
            cell = 931;
            hollowGlassOutRelationInfo = hollowGlassOutRelationInfoService
                    .getOne(new LambdaQueryWrapper<HollowGlassOutRelationInfo>()
                            .eq(HollowGlassOutRelationInfo::getCell, cell)
                            .eq(HollowGlassOutRelationInfo::getState, Const.HOLLOW_FLOW_CARD_START)
                    );
        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) {
@@ -331,7 +496,7 @@
//            获取当前中空任务未完成出片的玻璃信息
            List<HollowGlassQueueInfo> unFinishHollowQueueList = hollowGlassQueueInfoService.list(new LambdaQueryWrapper<HollowGlassQueueInfo>()
                    .eq(HollowGlassQueueInfo::getFlowCardId, hollowGlassOutRelationInfo.getFlowCardId())
                    .eq(HollowGlassQueueInfo::getCell, cell)
                    .eq(HollowGlassQueueInfo::getCell, hollowGlassOutRelationInfo.getCell())
                    .eq(HollowGlassQueueInfo::getState, Const.TEMPERING_NEW)
                    .orderByAsc(HollowGlassQueueInfo::getHollowSequence));
            if (CollectionUtil.isNotEmpty(unFinishHollowQueueList)) {
@@ -349,7 +514,6 @@
                        .set(HollowGlassOutRelationInfo::getState, Const.HOLLOW_FLOW_CARD_SUCCESS));
            }
        }
//        redisUtil.setCacheObject("dispatchHollowSwitch",true);
        //是否存在需要内部调度的格子:执行内部调度任务
        if (redisUtil.getCacheObject("dispatchHollowSwitch")) {
            //todo:获取笼内单格已经到齐的玻璃格子信息
@@ -391,33 +555,73 @@

    @Scheduled(fixedDelay = 1000)
    public void finishInBigStorageTask() throws Exception {
        ReadWriteEntity inkageEntity = miloService.readFromOpcUa("DLP2A.DLP2A.mesControl");
        if (true != Boolean.parseBoolean(inkageEntity.getValue() + "")) {
        S7DataZKDLPOne s7DataZKDLPOne = s7SerializerZKDLPOne.read(S7DataZKDLPOne.class);
        Boolean inkageEntity = s7DataZKDLPOne.getMesControl();
        if (true != inkageEntity) {
            log.info("当前为非联机状态，结束完成进片任务");
            return;
        }
        //获取进片任务表
        List<BigStorageCageTask> inTaskList = new ArrayList();
        List<String> glassIdList = new ArrayList<>();
        ReadWriteEntity toWord = miloService.readFromOpcUa("DLP2A.DLP2A.TO1");
        if ("0".equals(toWord.getValue() + "")) {
        String toWord = s7DataZKDLPOne.getTo1().toString();
        if ("0".equals(toWord)) {
            log.info("完成任务已执行，结束本次完成进片任务");
            return;
        }
        for (int i = 1; i <= 6; i++) {
            ReadWriteEntity requestWord = miloService.readFromOpcUa("DLP2A.DLP2A.DI" + i);
            ReadWriteEntity statetWord = miloService.readFromOpcUa("DLP2A.DLP2A.STATE" + i);
            ReadWriteEntity toOpcUa = miloService.readFromOpcUa("DLP2A.DLP2A.TO" + i);
            ReadWriteEntity fromOpcUa = miloService.readFromOpcUa("DLP2A.DLP2A.FROM" + i);
            String requestWord = "";
            String statetWord = "";
            String toOpcUa = "";
            String fromOpcUa = "";
            switch (i) {
                case 1:
                    requestWord = s7DataZKDLPOne.getId1();
                    statetWord = s7DataZKDLPOne.getState1().toString();
                    toOpcUa = s7DataZKDLPOne.getTo1().toString();
                    fromOpcUa = s7DataZKDLPOne.getFrom1().toString();
                    break;
                case 2:
                    requestWord = s7DataZKDLPOne.getId2();
                    statetWord = s7DataZKDLPOne.getState2().toString();
                    toOpcUa = s7DataZKDLPOne.getTo2().toString();
                    fromOpcUa = s7DataZKDLPOne.getFrom2().toString();
                    break;
                case 3:
                    requestWord = s7DataZKDLPOne.getId3();
                    statetWord = s7DataZKDLPOne.getState3().toString();
                    toOpcUa = s7DataZKDLPOne.getTo3().toString();
                    fromOpcUa = s7DataZKDLPOne.getFrom3().toString();
                    break;
                case 4:
                    requestWord = s7DataZKDLPOne.getId4();
                    statetWord = s7DataZKDLPOne.getState4().toString();
                    toOpcUa = s7DataZKDLPOne.getTo4().toString();
                    fromOpcUa = s7DataZKDLPOne.getFrom4().toString();
                    break;
                case 5:
                    requestWord = s7DataZKDLPOne.getId5();
                    statetWord = s7DataZKDLPOne.getState5().toString();
                    toOpcUa = s7DataZKDLPOne.getTo5().toString();
                    fromOpcUa = s7DataZKDLPOne.getFrom5().toString();
                    break;
                case 6:
                    requestWord = s7DataZKDLPOne.getId6();
                    statetWord = s7DataZKDLPOne.getState6().toString();
                    toOpcUa = s7DataZKDLPOne.getTo6().toString();
                    fromOpcUa = s7DataZKDLPOne.getFrom6().toString();
                    break;
            }

            if (null != requestWord.getValue()) {
//            if (null != requestWord.getValue()) {
            if (null != requestWord && !requestWord.isEmpty()) {
                BigStorageCageTask task = new BigStorageCageTask();
                task.setGlassId(requestWord.getValue() + "");
                task.setTargetSlot(Integer.parseInt(toOpcUa.getValue() + ""));
                task.setTaskState(Integer.parseInt(statetWord.getValue() + ""));
                task.setStartSlot(Integer.parseInt(fromOpcUa.getValue() + ""));
                task.setGlassId(requestWord);
                task.setTargetSlot(Integer.parseInt(toOpcUa));
                task.setTaskState(Integer.parseInt(statetWord));
                task.setStartSlot(Integer.parseInt(fromOpcUa));
                inTaskList.add(task);
                glassIdList.add(requestWord.getValue() + "");
                glassIdList.add(requestWord);
                continue;
            }
        }
@@ -489,30 +693,35 @@
                    .eq(HollowBigStorageCageHistoryTask::getGlassId, item.getGlassId()));
            item.setTargetSlot(0);
            //清空任务表数据
            bigStorageCageTaskService.updateTaskMessage("big_storage_cage_in_one_task", item);
//            bigStorageCageTaskService.updateTaskMessage("big_storage_cage_in_one_task", item);
        }
        //清空启动状态
        //向opc发送启动信号
        //向opc发送启动信号
        List<ReadWriteEntity> list = new ArrayList<>();
        for (int i = 1; i <= 6; i++) {
            list.add(generateReadWriteEntity("DLP2A.DLP2A.TO" + i, 0));
        }
        list.add(generateReadWriteEntity("DLP2A.DLP2A.MesReply", 0));
        miloService.writeToOpcWord(list);
        s7DataZKDLPOne = new S7DataZKDLPOne();
        s7DataZKDLPOne.setTo1(0);
        s7DataZKDLPOne.setTo2(0);
        s7DataZKDLPOne.setTo3(0);
        s7DataZKDLPOne.setTo4(0);
        s7DataZKDLPOne.setTo5(0);
        s7DataZKDLPOne.setTo6(0);
        s7SerializerZKDLPOne.write(s7DataZKDLPOne);
        s7DataZKDLPOne = new S7DataZKDLPOne();
        s7DataZKDLPOne.setMesReply(0);
        s7SerializerZKDLPOne.write(s7DataZKDLPOne);
    }

    @Scheduled(fixedDelay = 1000)
    public void finishOutBigStorageTask() throws Exception {
        ReadWriteEntity inkageEntity = miloService.readFromOpcUa("DLP2B.DLP2B.mesControl");
        if (true != Boolean.parseBoolean(inkageEntity.getValue() + "")) {
        S7DataZKDLPTwo s7DataZKDLPTwo = s7SerializerZKDLPTwo.read(S7DataZKDLPTwo.class);
        Boolean inkageEntity = s7DataZKDLPTwo.getMesControl();
        if (true != inkageEntity) {
            log.info("当前为非联机状态，结束完成出片任务");
            return;
        }
        //获取进片任务表
        List<BigStorageCageTask> outTaskList = bigStorageCageTaskService.queryTaskMessage(BIG_STORAGE_CAGE_OUT_TWO_TASK);
        //获取出片任务表
        List<BigStorageCageTask> outTaskList = getOutTaskList(s7DataZKDLPTwo);
        if (CollectionUtil.isEmpty(outTaskList)) {
            log.info("当前大车无进片玻璃，结束完成进片任务");
            log.info("当前大车无出片玻璃，结束完成出片任务");
            return;
        }
        List<BigStorageCageTask> unFinishTaskList = outTaskList.stream().filter(e -> e.getTaskState() <= 1 || e.getStartSlot() == 0).collect(Collectors.toList());
@@ -533,7 +742,7 @@
        taskMap.forEach((e1, v) -> {
            if (e1 == 2) {
                //进片完成
                log.info("3、获取进片已完成的玻璃信息id:{}", v);
                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());
@@ -561,7 +770,7 @@
                    List<Integer> slotList = storageCageDTOList.stream().map(UpdateHollowBigStorageCageDTO::getTargetSlot).distinct().collect(Collectors.toList());
                    hollowBigStorageCageDetailsService.updateDeviceIdBySlot(slotList);
                }
                log.info("4、大理片笼进片状态已完成已完成的玻璃信息id:{}", v);
                log.info("4、大理片笼出片状态已完成已完成的玻璃信息id:{}", v);
                updateSlotRemainBySlots(outSuccessGlassSlot);
            } else if (e1 == 3) {
                //破损处理
@@ -628,11 +837,12 @@
        }

//       重置任务表数据
        bigStorageCageTaskService.updateOutTaskMessage(BIG_STORAGE_CAGE_OUT_TWO_TASK);

        resetOutTask();
        //清空启动状态
        //向opc发送启动信号
        miloService.writeToOpcWord(generateReadWriteEntity("DLP2B.DLP2B.MesReply", 0));
        s7DataZKDLPTwo = new S7DataZKDLPTwo();
        s7DataZKDLPTwo.setMesReply(0);
        s7SerializerZKDLPTwo.write(s7DataZKDLPTwo);
    }

    private void dealDamageInTask(List<BigStorageCageTask> damageTaskList) {
@@ -712,7 +922,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 {
@@ -721,7 +931,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()));
            }
        }
@@ -737,7 +947,8 @@
    }


    private <T extends HollowBigStorageCageBaseInfo> Boolean hollowOutGlassByIsPair(List<T> list, int targetSlot, int isPair, int totalLayer, int isForce) {
    private <T extends HollowBigStorageCageBaseInfo> Boolean hollowOutGlassByIsPair(List<T> list,
                                                                                    int targetSlot, int isPair, int totalLayer, int isForce) throws Exception {
        List<T> resultList = new ArrayList<>();
        List<T> tempList = new ArrayList<>();
        int taskType = Const.BIG_STORAGE_AFTER_OUT;
@@ -749,6 +960,8 @@
                break;
            }
        }

        Integer slotWidth = sysConfigService.queryConfigValue(ConstSysConfig.HOLLOW_SLOT_WIDTH);
        if (isPair == 0 && isForce != 1) {
            taskType = Const.BIG_STORAGE_AFTER_DISPATCH;
            taskState = Const.GLASS_STATE_SCHEDULE_ING;
@@ -762,6 +975,16 @@
                        .ge(HollowBigStorageCage::getMaxThickness, list.get(0).getThickness())
                        .eq(HollowBigStorageCage::getRemainWidth, slotWidth)
                        .orderByAsc(HollowBigStorageCage::getMaxThickness).last("limit 1"));

                if (null == storageCage) {
                    //向plc发送报警:直通片台存在玻璃，无法继续直通
//                    miloService.writeToOpcWord(generateReadWriteEntity("DLP1A.DLP1A.alarmSignal", 16));
                    S7DataZKDLPOne s7DataZKDLPOne = new S7DataZKDLPOne();
                    s7DataZKDLPOne.setAlramSignal(16);
                    s7SerializerZKDLPOne.write(s7DataZKDLPOne);
                    Assert.isFalse(storageCage == null, "任务调度没有多余格子，结束调度任务");
                }

                targetSlot = storageCage.getSlot();
                hollowBigStorageCageService.update(new LambdaUpdateWrapper<HollowBigStorageCage>()
                        .set(HollowBigStorageCage::getRemainWidth, 0).eq(HollowBigStorageCage::getSlot, targetSlot));
@@ -783,45 +1006,114 @@
     * @param totalLayer
     * @return
     */
    private <T extends HollowBigStorageCageBaseInfo> Boolean computeOutGlassInfo(List<T> list, String tableName, int targetSlot, int state, int taskType, int totalLayer, int isForce) {
    private <T extends HollowBigStorageCageBaseInfo> Boolean computeOutGlassInfo(List<T> list, String tableName,
                                                                                 int targetSlot, int state, int taskType, int totalLayer, int isForce) {
        //任务数据:获取车子存放玻璃最大数量,玻璃间隔
        List<BigStorageCageTask> tempList = new ArrayList<>();
        List<T> tempTList = new ArrayList<>();
        List<T> templist = new ArrayList<>();
        //打车剩余尺寸
        Integer remainWidth = carWidth;
        Integer remainWidth = sysConfigService.queryConfigValue(ConstSysConfig.HOLLOW_SLOT_WIDTH);
        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());
        for (T e : list) {
            if (tempList.size() >= outCarMaxSize || Math.max((int) e.getWidth(), (int) e.getHeight()) > remainWidth) {
            if (templist.size() >= outCarMaxSize || Math.max((int) e.getWidth(), (int) e.getHeight()) > remainWidth) {
                break;
            }
            //计算当前出片车剩尺寸
            remainWidth = remainWidth - Math.max((int) e.getWidth(), (int) e.getHeight()) - glassGap;
            tempTList.add(e);
            tempList.add(new BigStorageCageTask(e.getGlassId(), e.getSlot(), targetSlot,
                    0));
            templist.add(e);
        }
        Assert.isFalse(CollectionUtil.isEmpty(tempList), "未获取出片数据，结束出片任务");
        log.info("获取出片任务数据{}条，执行保存", tempList.size());
        List<BigStorageCageTask> bigStorageCageTaskList = tempList;
        Assert.isFalse(CollectionUtil.isEmpty(templist), "未获取出片数据，结束出片任务");
        log.info("获取出片任务数据{}条，执行保存", templist.size());
        List<T> baseInfoList = templist;
        if (1 != isForce) {
            if (taskType == Const.BIG_STORAGE_AFTER_OUT) {
                if (tempList.size() <= totalLayer) {
                    bigStorageCageTaskList = tempList;
                //校验防止小于等于总层数玻璃片序不匹配的问题，该问题多出现在大片玻璃，3层
                if (templist.size() <= 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 {
                    int remainCount = tempList.size() % totalLayer;
                    bigStorageCageTaskList = tempList.subList(0, tempList.size() - remainCount);
                    //大于总层数先取totalLayer倍数数量的玻璃，保证大车上的玻璃成对传
                    int remainCount = templist.size() % totalLayer;
                    if (targetSlot == 930) {
                        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);
                    }
                }
            }
        }

        List<String> glassIds = bigStorageCageTaskList.stream().map(BigStorageCageTask::getGlassId).collect(Collectors.toList());
        int glassCount = bigStorageCageTaskList.size();
        List<String> glassIds = baseInfoList.stream().map(T::getGlassId).collect(Collectors.toList());
        int glassCount = baseInfoList.size();
        List<BigStorageCageTask> bigStorageCageTaskList = new ArrayList<>();
        //生成出片任务条数不足6补全
        while (bigStorageCageTaskList.size() < 6) {
            bigStorageCageTaskList.add(new BigStorageCageTask("", 0, 0, 0));
        for (T t : baseInfoList) {
            bigStorageCageTaskList.add(new BigStorageCageTask(t.getGlassId(), t.getSlot(), targetSlot, 0));
        }
        //清空任务表数据
        bigStorageCageTaskService.removeAll(tableName);
        bigStorageCageTaskService.saveTaskMessage(tableName, bigStorageCageTaskList);
        resetOutTask();
        log.info("生成出片任务数据{}", bigStorageCageTaskList);
        S7DataZKDLPTwo s7DataZKDLPTwo = new S7DataZKDLPTwo();
        for (int i = 0; i < bigStorageCageTaskList.size() && i < 6; i++) {
            String glassId = bigStorageCageTaskList.get(i).getGlassId();
            Integer startSlot = bigStorageCageTaskList.get(i).getStartSlot();
            Integer target = bigStorageCageTaskList.get(i).getTargetSlot();
            if (startSlot > 0) {
                switch (i) {
                    case 0:
                        s7DataZKDLPTwo.setId1(glassId);
                        s7DataZKDLPTwo.setFrom1(startSlot);
                        s7DataZKDLPTwo.setTo1(target);
                        break;
                    case 1:
                        s7DataZKDLPTwo.setId2(glassId);
                        s7DataZKDLPTwo.setFrom2(startSlot);
                        s7DataZKDLPTwo.setTo2(target);
                        break;
                    case 2:
                        s7DataZKDLPTwo.setId3(glassId);
                        s7DataZKDLPTwo.setFrom3(startSlot);
                        s7DataZKDLPTwo.setTo3(target);
                        break;
                    case 3:
                        s7DataZKDLPTwo.setId4(glassId);
                        s7DataZKDLPTwo.setFrom4(startSlot);
                        s7DataZKDLPTwo.setTo4(target);
                        break;
                    case 4:
                        s7DataZKDLPTwo.setId5(glassId);
                        s7DataZKDLPTwo.setFrom5(startSlot);
                        s7DataZKDLPTwo.setTo5(target);
                        break;
                    case 5:
                        s7DataZKDLPTwo.setId6(glassId);
                        s7DataZKDLPTwo.setFrom6(startSlot);
                        s7DataZKDLPTwo.setTo6(target);
                        break;
                }
            }
        }
        s7SerializerZKDLPTwo.write(s7DataZKDLPTwo);
        log.info("出片任务写入数据{}", s7DataZKDLPTwo);
        S7DataZKDLPTwo s7DataZKDLPTwo1 = s7SerializerZKDLPTwo.read(S7DataZKDLPTwo.class);
        log.info("写入出片任务后读取数据{}", s7DataZKDLPTwo1);
        List<HollowBigStorageCageHistoryTask> historyList = bigStorageCageTaskList.stream().filter(e -> StringUtils.isNotBlank(e.getGlassId())).map(e -> {
            HollowBigStorageCageHistoryTask history = new HollowBigStorageCageHistoryTask();
            BeanUtils.copyProperties(e, history);
@@ -829,16 +1121,18 @@
            history.setTaskType(taskType);
            return history;
        }).collect(Collectors.toList());
        log.info("历史任务保存{}", historyList);
        hollowBigStorageCageHistoryTaskService.saveBatch(historyList);

        log.info("将出片玻璃{}玻璃状态改为出片中", glassIds);
        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 {
            miloService.writeToOpcWord(generateReadWriteEntity("DLP2B.DLP2B.MesReply", 1));
            s7DataZKDLPTwo = new S7DataZKDLPTwo();
            s7DataZKDLPTwo.setMesReply(1);
            s7SerializerZKDLPTwo.write(s7DataZKDLPTwo);
        } catch (Exception e) {
            e.printStackTrace();
        }
@@ -851,11 +1145,10 @@
                .in(HollowBigStorageCageDetails::getSlot, slotList).in(HollowBigStorageCageDetails::getState, Const.GLASS_STATE_IN_ALL));
        Map<Integer, Double> slotRemainMap = new HashMap<>();
        //是否存在有格子非空的玻璃
        Integer glassGap = sysConfigService.queryConfigValue(ConstSysConfig.HOLLOW_GLASS_GAP);
        Integer slotWidth = sysConfigService.queryConfigValue(ConstSysConfig.HOLLOW_SLOT_WIDTH);
        if (CollectionUtils.isNotEmpty(inSlotGlassList)) {
            //存在  将格子内的玻璃分别进行更新
//            List<HollowBigStorageCage> hollowBigStorageCageList = hollowBigStorageCageService.list(new LambdaQueryWrapper<HollowBigStorageCage>()
//                    .lt(HollowBigStorageCage::getRemainWidth, 0).in(HollowBigStorageCage::getSlot, slotList));
//            List<Integer> resultSlotList = hollowBigStorageCageList.stream().map(HollowBigStorageCage::getSlot).collect(Collectors.toList());
            slotRemainMap = inSlotGlassList.stream()
                    .collect(Collectors.groupingBy(HollowBigStorageCageDetails::getSlot, Collectors.summingDouble(item -> Math.max(item.getWidth(), item.getHeight()) + glassGap)));
            slotRemainMap.forEach((e, v) -> {
@@ -880,4 +1173,54 @@
                .value(value)
                .build();
    }

    //读取出片地址
    private List<BigStorageCageTask> getOutTaskList(S7DataZKDLPTwo s7DataZKDLPTwo) {
        List<BigStorageCageTask> outTaskList = new ArrayList<>();
        List<String> glassIds = s7DataZKDLPTwo.getIds();
        List<Integer> startSlots = s7DataZKDLPTwo.getFroms();
        List<Integer> endSlots = s7DataZKDLPTwo.getTos();
        List<Integer> states = s7DataZKDLPTwo.getStates();
        for (int i = 0; i < 6; i++) {
            if (glassIds.get(i) != null && !glassIds.get(i).isEmpty()) {
                BigStorageCageTask bigStorageCageTask = new BigStorageCageTask();
                bigStorageCageTask.setGlassId(glassIds.get(i));
                bigStorageCageTask.setStartSlot(startSlots.get(i));
                bigStorageCageTask.setTargetSlot(endSlots.get(i));
                bigStorageCageTask.setTaskState(states.get(i));
                outTaskList.add(bigStorageCageTask);
            }
        }
        return outTaskList;
    }

    //重置任务表
    private void resetOutTask() {
        S7DataZKDLPTwo s7DataZKDLPTwo = new S7DataZKDLPTwo();
        s7DataZKDLPTwo.setId1("");
        s7DataZKDLPTwo.setId2("");
        s7DataZKDLPTwo.setId3("");
        s7DataZKDLPTwo.setId4("");
        s7DataZKDLPTwo.setId5("");
        s7DataZKDLPTwo.setId6("");
        s7DataZKDLPTwo.setFrom1(0);
        s7DataZKDLPTwo.setFrom2(0);
        s7DataZKDLPTwo.setFrom3(0);
        s7DataZKDLPTwo.setFrom4(0);
        s7DataZKDLPTwo.setFrom5(0);
        s7DataZKDLPTwo.setFrom6(0);
        s7DataZKDLPTwo.setTo1(0);
        s7DataZKDLPTwo.setTo2(0);
        s7DataZKDLPTwo.setTo3(0);
        s7DataZKDLPTwo.setTo4(0);
        s7DataZKDLPTwo.setTo5(0);
        s7DataZKDLPTwo.setTo6(0);
        s7DataZKDLPTwo.setState1(0);
        s7DataZKDLPTwo.setState2(0);
        s7DataZKDLPTwo.setState3(0);
        s7DataZKDLPTwo.setState4(0);
        s7DataZKDLPTwo.setState5(0);
        s7DataZKDLPTwo.setState6(0);
        s7SerializerZKDLPTwo.write(s7DataZKDLPTwo);
    }
}