OPC通讯修改为S7通讯

ZengTao

2025-05-22 b4ff04d7dd22f0e48bf386cd422e885aef08fed7

 hangzhoumesParent/moduleService/CacheVerticalGlassModule/src/main/java/com/mes/job/OpcPlcStorageCageNewTask.java

@@ -4,6 +4,7 @@
import cn.hutool.core.lang.Assert;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.github.xingshuangs.iot.protocol.s7.serializer.S7Serializer;
import com.github.yulichang.toolkit.JoinWrappers;
import com.kangaroohy.milo.model.ReadWriteEntity;
import com.kangaroohy.milo.service.MiloService;
@@ -24,12 +25,16 @@
import com.mes.bigstoragecagetask.service.BigStorageCageTaskService;
import com.mes.bigstoragetask.entity.UpdateBigStorageCageDTO;
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.edgglasstask.entity.EdgGlassTaskInfo;
import com.mes.edgglasstask.service.EdgGlassTaskInfoService;
import com.mes.glassinfo.entity.GlassInfo;
import com.mes.glassinfo.service.GlassInfoService;
import com.mes.s7.entity.S7DataDLPOne;
import com.mes.s7.entity.S7DataDLPTwo;
import com.mes.sysconfig.service.SysConfigService;
import com.mes.temperingglass.entity.TemperingGlassInfo;
import com.mes.temperingglass.service.TemperingGlassInfoService;
import com.mes.utils.RedisUtil;
@@ -37,7 +42,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,6 +80,17 @@
    @Autowired(required = false)
    MiloService miloService;

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

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

    @Resource
    SysConfigService sysConfigService;

    /**
     * 直通格子
     */
@@ -83,54 +99,50 @@
    @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.temperingOutTargetPosition}")
    private Integer temperingOutTargetPosition;
    @Value("${mes.artificialOutTargetPosition}")
    private Integer artificialOutTargetPosition;
    @Value("${mes.slotMaxHeight}")
    private Integer slotMaxHeight;

    @Scheduled(fixedDelay = 1000)
    public void inBigStorageTask() throws Exception {
        ReadWriteEntity inkageEntity = miloService.readFromOpcUa("DLP1A.DLP1A.mesControl");
        if (true != Boolean.parseBoolean(inkageEntity.getValue() + "")) {
        S7DataDLPOne s7DataDLPOne = s7SerializerDLPOne.read(S7DataDLPOne.class);
//        ReadWriteEntity inkageEntity = miloService.readFromOpcUa("DLP1A.DLP1A.mesControl");
//        if (true != Boolean.parseBoolean(inkageEntity.getValue() + "")) {
        Boolean inkageEntity = s7DataDLPOne.getMesControl();
        if (true != inkageEntity) {
            log.info("当前为非联机状态，结束进片任务");
            return;
        }
        ReadWriteEntity requestEntity = miloService.readFromOpcUa("DLP1A.DLP1A.RequestMes");
        if (!"1".equals(requestEntity.getValue() + "")) {
//        ReadWriteEntity requestEntity = miloService.readFromOpcUa("DLP1A.DLP1A.RequestMes");
//        if (!"1".equals(requestEntity.getValue() + "")) {
        String requestEntity = s7DataDLPOne.getRequestMes().toString();
        if (!"1".equals(requestEntity)) {
            log.info("当前未收到进片请求，结束进片任务");
            return;
        }
        ReadWriteEntity mesReplyEntity = miloService.readFromOpcUa("DLP1A.DLP1A.MesReply");
        if ("1".equals(mesReplyEntity.getValue() + "")) {
//        ReadWriteEntity mesReplyEntity = miloService.readFromOpcUa("DLP1A.DLP1A.MesReply");
//        if ("1".equals(mesReplyEntity.getValue() + "")) {
        String mesReplyEntity = s7DataDLPOne.getMesReply().toString();
        if (!"1".equals(mesReplyEntity)) {
            log.info("有正在执行的任务，结束进片任务");
            return;
        }
        //获取进片任务信息
        List<BigStorageCageTask> inTaskList = new ArrayList();
        ReadWriteEntity fromOpcUa = miloService.readFromOpcUa("DLP1A.DLP1A.FROM1");
//        ReadWriteEntity fromOpcUa = miloService.readFromOpcUa("DLP1A.DLP1A.FROM1");
        String fromOpcUa = s7DataDLPOne.getFrom1().toString();

        List<Short> states = s7DataDLPOne.getStates();
        List<String> glassIdList = new ArrayList<>();
        for (int i = 1; i <= 6; i++) {
            ReadWriteEntity requestWord = miloService.readFromOpcUa("DLP1A.DLP1A.DI" + i);
            if (null != requestWord.getValue()) {
//            ReadWriteEntity requestWord = miloService.readFromOpcUa("DLP1A.DLP1A.DI" + i);
            String requestWord = states.get(i).toString();
//            if (null != requestWord.getValue()) {
            if (null != requestWord) {
                BigStorageCageTask task = new BigStorageCageTask();
                task.setGlassId(requestWord.getValue() + "");
                task.setStartSlot(Integer.parseInt(fromOpcUa.getValue() + ""));
//                task.setGlassId(requestWord.getValue() + "");
                task.setGlassId(requestWord);
//                task.setStartSlot(Integer.parseInt(fromOpcUa.getValue() + ""));
                task.setStartSlot(Integer.parseInt(fromOpcUa));
                inTaskList.add(task);
                glassIdList.add(requestWord.getValue() + "");
//                glassIdList.add(requestWord.getValue() + "");
                glassIdList.add(requestWord);
                continue;
            }
        }
@@ -139,11 +151,27 @@
            return;
        }
        log.info("获取任务的玻璃id：{}", glassIdList);
//        ReadWriteEntity countEntity = miloService.readFromOpcUa("DLP1A.DLP1A.glassCount");
        String countEntity = s7DataDLPOne.getGlassCount().toString();
//        if (null == countEntity.getValue() || Integer.parseInt(countEntity.getValue() + "") != glassIdList.size()) {
        if (null == countEntity || Integer.parseInt(countEntity) != glassIdList.size()) {
            log.info("当前大车进片玻璃数量{}与mes读取到的数量{}不匹配，结束进片任务", countEntity, glassIdList.size());
            //向plc发送报警:当前大车进片玻璃数量与mes读取到的数量不匹配
//            miloService.writeToOpcWord(generateReadWriteEntity("DLP1A.DLP1A.alarmSignal", 1));
            s7DataDLPOne = new S7DataDLPOne();
            s7DataDLPOne.setAlramSignal((short) 1);
            s7SerializerDLPOne.write(s7DataDLPOne);
            return;
        }
        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());
                //todo:向plc发送报警
                //向plc发送报警:同一车进片玻璃存在相同
//                miloService.writeToOpcWord(generateReadWriteEntity("DLP1A.DLP1A.alarmSignal", 2));
                s7DataDLPOne = new S7DataDLPOne();
                s7DataDLPOne.setAlramSignal((short) 2);
                s7SerializerDLPOne.write(s7DataDLPOne);
                return;
            }
        }
@@ -151,37 +179,59 @@
                .in(BigStorageCageDetails::getState, Const.GLASS_STATE_IN_ALL_ZERO));
        if (CollectionUtil.isNotEmpty(detailsList)) {
            log.info("理片笼存在相同的进片玻璃{}，结束本次任务", detailsList);
            //todo:向plc发送报警
            //向plc发送报警:理片笼存在相同的进片玻璃
//            miloService.writeToOpcWord(generateReadWriteEntity("DLP1A.DLP1A.alarmSignal", 4));
            s7DataDLPOne = new S7DataDLPOne();
            s7DataDLPOne.setAlramSignal((short) 4);
            s7SerializerDLPOne.write(s7DataDLPOne);
            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发送报警:进片任务数量与系统查询到的玻璃数量不匹配
//            miloService.writeToOpcWord(generateReadWriteEntity("DLP1A.DLP1A.alarmSignal", 8));
            s7DataDLPOne = new S7DataDLPOne();
            s7DataDLPOne.setAlramSignal((short) 8);
            s7SerializerDLPOne.write(s7DataDLPOne);
            return;
        }
        Integer glassGap = sysConfigService.queryConfigValue(ConstSysConfig.VERTICAL_GLASS_GAP);
        Integer slotMaxthickness = sysConfigService.queryConfigValue(ConstSysConfig.VERTICAL_SLOT_MAX_THICKNESS);
        Integer slotWidth = sysConfigService.queryConfigValue(ConstSysConfig.VERTICAL_SLOT_WIDTH);
        Integer slotMaxHeight = sysConfigService.queryConfigValue(ConstSysConfig.VERTICAL_SLOT_MAX_HEIGHT);
        //按照玻璃厚度分组，判断剩余格子是否可以存放
        Map<Double, Long> thickCountMap = glassInfoList.stream().collect(Collectors.groupingBy(GlassInfo::getThickness, Collectors.counting()));
        for (Map.Entry<Double, Long> entry : thickCountMap.entrySet()) {
            int count = bigStorageCageService.count(new LambdaQueryWrapper<BigStorageCage>()
                    .eq(BigStorageCage::getEnableState, Const.SLOT_ON).eq(BigStorageCage::getRemainWidth, slotWidth)
                    .le(BigStorageCage::getMinThickness, entry.getKey())
                    .ge(BigStorageCage::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 = bigStorageCageService.count(new LambdaQueryWrapper<BigStorageCage>()
                        .eq(BigStorageCage::getEnableState, Const.SLOT_ON).eq(BigStorageCage::getRemainWidth, slotWidth)
                        .le(BigStorageCage::getMinThickness, entry.getKey())
                        .ge(BigStorageCage::getMaxThickness, entry.getKey()));
                if (count < entry.getValue()) {
                    log.info("笼内格子剩余数量不足，结束本次进片");
                    //向plc发送报警:笼内格子剩余数量不足
//                    miloService.writeToOpcWord(generateReadWriteEntity("DLP1A.DLP1A.alarmSignal", 16));
                    s7DataDLPOne = new S7DataDLPOne();
                    s7DataDLPOne.setAlramSignal((short) 16);
                    s7SerializerDLPOne.write(s7DataDLPOne);
                    return;
                }
            }
        }
        //todo:超大尺寸
        if (slotMaxHeight < Math.min(glassInfoList.get(0).getWidth(), glassInfoList.get(0).getHeight())) {
        //超大尺寸
        if (slotMaxHeight < Math.min(glassInfoList.get(0).getWidth(), glassInfoList.get(0).getHeight()) || glassInfoList.get(0).getThickness() >= slotMaxthickness) {
            int count = bigStorageCageDetailsService.count(new LambdaQueryWrapper<BigStorageCageDetails>()
                    .eq(BigStorageCageDetails::getSlot, THROUGH_SLOT)
                    .in(BigStorageCageDetails::getState, Const.GLASS_STATE_IN_ALL));
            if (count > 0) {
                log.info("直通片台存在玻璃，结束本次进片");
                //todo:向plc发送报警
                //向plc发送报警:直通片台存在玻璃，无法继续直通
//                miloService.writeToOpcWord(generateReadWriteEntity("DLP1A.DLP1A.alarmSignal", 64));
                s7DataDLPOne = new S7DataDLPOne();
                s7DataDLPOne.setAlramSignal((short) 64);
                s7SerializerDLPOne.write(s7DataDLPOne);
                return;
            }
        }
@@ -189,11 +239,16 @@
        //修改磨边对列表的玻璃状态
        edgGlassTaskInfoService.update(new LambdaUpdateWrapper<EdgGlassTaskInfo>()
                .set(EdgGlassTaskInfo::getState, Const.EDG_GLASS_SUCCESS).in(EdgGlassTaskInfo::getGlassId, glassIdList));
        //报工
        for (String glass : glassIdList) {
            damageService.autoSubmitReport(glass, inTaskList.get(0).getStartSlot(), "磨边", "进大理片笼", 1);
        }

        Map<String, List<GlassInfo>> glassListMap = glassInfoList.stream().collect(Collectors.groupingBy(GlassInfo::getGlassId));
        //计算目标格子
        List<BigStorageCageHistoryTask> historyTasks = new ArrayList<>();
        //超大尺寸与正常尺寸玻璃计算方式不一样
        if (slotMaxHeight > Math.min(glassInfoList.get(0).getWidth(), glassInfoList.get(0).getHeight())) {
        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);
                BigStorageDTO bigStorageDTO = bigStorageGlassInfoService.queryBigStorageTargetSlot(info.getEngineerId(), info.getTemperingLayoutId(), info.getTemperingFeedSequence());
@@ -219,7 +274,9 @@
                cageDetails.setState(Const.GLASS_STATE_NEW);
                cageDetails.setDeviceId(bigStorageDTO.getDeviceId());
                cageDetails.setSequence(bigStorageDTO.getSlotSequence());
                cageDetails.setAngle((int) info.getAngle());
                cageDetails.setGap(glassGap);
                cageDetails.setFilmsId(info.getFilmsid());
                cageDetails.setId(null);
                bigStorageCageDetailsService.save(cageDetails);
            }
@@ -242,30 +299,63 @@
            cageDetails.setDeviceId(0);
            cageDetails.setSequence(0);
            cageDetails.setGap(glassGap);
            cageDetails.setAngle((int) info.getAngle());
            cageDetails.setFilmsId(info.getFilmsid());
            cageDetails.setId(null);
            bigStorageCageDetailsService.save(cageDetails);
        }
        //历史数据入库
        bigStorageCageHistoryTaskService.saveBatch(historyTasks);
        //向opc发送启动信号
        List<ReadWriteEntity> list = new ArrayList<>();
        for (int i = 1; i <= inTaskList.size(); i++) {
            list.add(generateReadWriteEntity("DLP1A.DLP1A.TO" + i, inTaskList.get(i - 1).getTargetSlot()));
//        List<ReadWriteEntity> list = new ArrayList<>();
//        for (int i = 1; i <= inTaskList.size(); i++) {
//            list.add(generateReadWriteEntity("DLP1A.DLP1A.TO" + i, inTaskList.get(i - 1).getTargetSlot()));
//        }
//        list.add(generateReadWriteEntity("DLP1A.DLP1A.MesReply", 1));
//        miloService.writeToOpcWord(list);
        s7DataDLPOne = new S7DataDLPOne();
        for (int i = 0; i < inTaskList.size() && i < 6; i++) {
            short value = (short) Integer.parseInt(inTaskList.get(i).getTargetSlot().toString());
            switch (i) {
                case 0:
                    s7DataDLPOne.setTo1(value);
                    break;
                case 1:
                    s7DataDLPOne.setTo2(value);
                    break;
                case 2:
                    s7DataDLPOne.setTo3(value);
                    break;
                case 3:
                    s7DataDLPOne.setTo4(value);
                    break;
                case 4:
                    s7DataDLPOne.setTo5(value);
                    break;
                case 5:
                    s7DataDLPOne.setTo6(value);
                    break;
            }
        }
        list.add(generateReadWriteEntity("DLP1A.DLP1A.MesReply", 1));
        miloService.writeToOpcWord(list);
        s7SerializerDLPOne.write(s7DataDLPOne);

    }

    @Scheduled(fixedDelay = 1000)
    public void outBigStorageTask() throws Exception {
        Date startDate = new Date();
        ReadWriteEntity inkageEntity = miloService.readFromOpcUa("DLP1B.DLP1B.mesControl");
        if (true != Boolean.parseBoolean(inkageEntity.getValue() + "")) {
        S7DataDLPTwo s7DataWLTwo = s7SerializerDLPTwo.read(S7DataDLPTwo.class);
//        ReadWriteEntity inkageEntity = miloService.readFromOpcUa("DLP1B.DLP1B.mesControl");
//        if (true != Boolean.parseBoolean(inkageEntity.getValue() + "")) {
        Boolean inkageEntity = s7DataWLTwo.getMesControl();
        if (true != inkageEntity) {
            log.info("当前为非联机状态，结束进片任务");
            return;
        }
        ReadWriteEntity requestEntity = miloService.readFromOpcUa("DLP1B.DLP1B.RequestMes");
        if (!"1".equals(requestEntity.getValue() + "")) {
//        ReadWriteEntity requestEntity = miloService.readFromOpcUa("DLP1B.DLP1B.RequestMes");
//        if (!"1".equals(requestEntity.getValue() + "")) {
        String requestEntity = s7DataWLTwo.getRequestMes().toString();
        if (!"1".equals(requestEntity)) {
            log.info("当前未收到出片请求，结束出片任务");
            return;
        }
@@ -278,19 +368,11 @@
        //是否允许钢化
        //是否有正在钢化的玻璃:钢化小片表关联历史任务表，筛选未出笼的玻璃信息
//            获取当前钢化任务未完成出片的玻璃信息

        Integer temperingOutTargetPosition = sysConfigService.queryConfigValue(ConstSysConfig.VERTICAL_TEMPERING_OUT_TARGET_POSITION);
        List<TemperingGlassInfo> unFinishTemperingGlassInfoList = temperingGlassInfoService.list(new LambdaQueryWrapper<TemperingGlassInfo>()
                .eq(TemperingGlassInfo::getState, Const.TEMPERING_NEW).orderByAsc(TemperingGlassInfo::getTemperingFeedSequence));
                .eq(TemperingGlassInfo::getState, Const.TEMPERING_NEW).orderByAsc(TemperingGlassInfo::getTemperingLayoutId).orderByAsc(TemperingGlassInfo::getTemperingFeedSequence));
        if (CollectionUtil.isNotEmpty(unFinishTemperingGlassInfoList)) {
//            List<String> glassIdList = unFinishTemperingGlassInfoList.stream().map(TemperingGlassInfo::getGlassId).collect(Collectors.toList());
//            List<BigStorageCageHistoryTask> historyTaskList = bigStorageCageHistoryTaskService.list(new LambdaQueryWrapper<BigStorageCageHistoryTask>()
//                    .eq(BigStorageCageHistoryTask::getTaskType, Const.BIG_STORAGE_BEFORE_OUT)
//                    .in(BigStorageCageHistoryTask::getGlassId, glassIdList));
//            List<TemperingGlassInfo> temperingGlassList = unFinishTemperingGlassInfoList;
//            if (CollectionUtil.isNotEmpty(historyTaskList)) {
//                List<String> taskGlassList = historyTaskList.stream().map(BigStorageCageHistoryTask::getGlassId).collect(Collectors.toList());
//                temperingGlassList = unFinishTemperingGlassInfoList.stream().filter(e -> !taskGlassList.contains(e.getGlassId())).collect(Collectors.toList());
//            }
//            if (CollectionUtil.isNotEmpty(unFinishTemperingGlassInfoList)) {
            log.info("有正在出片的钢化任务");
            computeOutGlassInfoByVirtualSlot(unFinishTemperingGlassInfoList, "big_storage_cage_out_one_task", temperingOutTargetPosition, Const.GLASS_STATE_OUT_ING, Const.BIG_STORAGE_BEFORE_OUT);
            Date endDate = new Date();
@@ -319,9 +401,9 @@
                for (TemperingLayoutDTO item : temperingLayoutDTOList) {
//                    if (item.getEngineerId().equals(redisUtil.getCacheObject("temperingengineerId"))) {
                    List<TemperingGlassInfo> temperingGlassInfos = glassInfoService.selectJoinList(TemperingGlassInfo.class, JoinWrappers.lambda(GlassInfo.class)
                            .selectAll(GlassInfo.class)
                            .select("-1 as state")
                            .selectAs(BigStorageCageDetails::getSlot, TemperingGlassInfo::getSlot)
                            .select("-1 as state,t.filmsid as films_id,t.glass_id,t.flow_card_id,t.glass_type,t.width,t.height" +
                                    ",t.thickness,t.ishorizontal,t.tempering_layout_id,t.tempering_feed_sequence,t.x_coordinate,t.y_coordinate," +
                                    "t.angle,t1.slot,t.engineer_id")
                            .innerJoin(BigStorageCageDetails.class, BigStorageCageDetails::getGlassId, GlassInfo::getGlassId)
                            .eq(BigStorageCageDetails::getState, Const.GLASS_STATE_IN)
                            .eq(GlassInfo::getTemperingLayoutId, item.getTemperingLayoutId())
@@ -339,6 +421,8 @@
            }
        }
        //是否有人工下片任务   有直接出
        Integer artificialOutTargetPosition = sysConfigService.queryConfigValue(ConstSysConfig.VERTICAL_ARTIFICIAL_OUT_TARGET_POSITION);
        Integer outCarMaxSize = sysConfigService.queryConfigValue(ConstSysConfig.VERTICAL_OUT_CAR_SIZE);
        List<BigStorageCageDetails> artificialList = bigStorageCageDetailsService.list(new LambdaQueryWrapper<BigStorageCageDetails>()
                .eq(BigStorageCageDetails::getState, Const.GLASS_STATE_ARTIFICIAL)
                .orderByAsc(BigStorageCageDetails::getSlot)
@@ -391,8 +475,11 @@

    @Scheduled(fixedDelay = 1000)
    public void finishInBigStorageTask() throws Exception {
        ReadWriteEntity inkageEntity = miloService.readFromOpcUa("DLP1A.DLP1A.mesControl");
        if (true != Boolean.parseBoolean(inkageEntity.getValue() + "")) {
        S7DataDLPOne s7DataDLPOne = s7SerializerDLPOne.read(S7DataDLPOne.class);
//        ReadWriteEntity inkageEntity = miloService.readFromOpcUa("DLP1A.DLP1A.mesControl");
//        if (true != Boolean.parseBoolean(inkageEntity.getValue() + "")) {
        Boolean inkageEntity = s7DataDLPOne.getMesControl();
        if (true != inkageEntity) {
            log.info("当前为非联机状态，结束完成进片任务");
            return;
        }
@@ -401,25 +488,75 @@
        List<BigStorageCageTask> inTaskList = new ArrayList();

        List<String> glassIdList = new ArrayList<>();
        ReadWriteEntity toWord = miloService.readFromOpcUa("DLP1A.DLP1A.TO1");
        if ("0".equals(toWord.getValue() + "")) {
//        ReadWriteEntity toWord = miloService.readFromOpcUa("DLP1A.DLP1A.TO1");
//        if ("0".equals(toWord.getValue() + "")) {
        String toWord = s7DataDLPOne.getTo1().toString();
        if ("0".equals(toWord)) {
            log.info("完成任务已执行，结束本次完成进片任务");
            return;
        }
        for (int i = 1; i <= 6; i++) {
            ReadWriteEntity requestWord = miloService.readFromOpcUa("DLP1A.DLP1A.DI" + i);
            ReadWriteEntity statetWord = miloService.readFromOpcUa("DLP1A.DLP1A.STATE" + i);
            ReadWriteEntity toOpcUa = miloService.readFromOpcUa("DLP1A.DLP1A.TO" + i);
            ReadWriteEntity fromOpcUa = miloService.readFromOpcUa("DLP1A.DLP1A.FROM" + i);
//            ReadWriteEntity requestWord = miloService.readFromOpcUa("DLP1A.DLP1A.DI" + i);
//            ReadWriteEntity statetWord = miloService.readFromOpcUa("DLP1A.DLP1A.STATE" + i);
//            ReadWriteEntity toOpcUa = miloService.readFromOpcUa("DLP1A.DLP1A.TO" + i);
//            ReadWriteEntity fromOpcUa = miloService.readFromOpcUa("DLP1A.DLP1A.FROM" + i);
            String requestWord = "";
            String statetWord = "";
            String toOpcUa = "";
            String fromOpcUa = "";
            switch (i) {
                case 0:
                    requestWord = s7DataDLPOne.getId1().toString();
                    statetWord = s7DataDLPOne.getState1().toString();
                    toOpcUa = s7DataDLPOne.getTo1().toString();
                    fromOpcUa = s7DataDLPOne.getFrom1().toString();
                    break;
                case 1:
                    requestWord = s7DataDLPOne.getId2().toString();
                    statetWord = s7DataDLPOne.getState2().toString();
                    toOpcUa = s7DataDLPOne.getTo2().toString();
                    fromOpcUa = s7DataDLPOne.getFrom2().toString();
                    break;
                case 2:
                    requestWord = s7DataDLPOne.getId3().toString();
                    statetWord = s7DataDLPOne.getState3().toString();
                    toOpcUa = s7DataDLPOne.getTo3().toString();
                    fromOpcUa = s7DataDLPOne.getFrom3().toString();
                    break;
                case 3:
                    requestWord = s7DataDLPOne.getId4().toString();
                    statetWord = s7DataDLPOne.getState4().toString();
                    toOpcUa = s7DataDLPOne.getTo4().toString();
                    fromOpcUa = s7DataDLPOne.getFrom4().toString();
                    break;
                case 4:
                    requestWord = s7DataDLPOne.getId5().toString();
                    statetWord = s7DataDLPOne.getState5().toString();
                    toOpcUa = s7DataDLPOne.getTo5().toString();
                    fromOpcUa = s7DataDLPOne.getFrom5().toString();
                    break;
                case 5:
                    requestWord = s7DataDLPOne.getId6().toString();
                    statetWord = s7DataDLPOne.getState6().toString();
                    toOpcUa = s7DataDLPOne.getTo6().toString();
                    fromOpcUa = s7DataDLPOne.getFrom6().toString();
                    break;
            }

            if (null != requestWord.getValue()) {
//            if (null != requestWord.getValue()) {
            if (null != requestWord) {
                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.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.getValue() + "");
                glassIdList.add(requestWord);
                continue;
            }
        }
@@ -470,18 +607,30 @@
        //清空启动状态
        //向opc发送启动信号
        //向opc发送启动信号
        List<ReadWriteEntity> list = new ArrayList<>();
        for (int i = 1; i <= 6; i++) {
            list.add(generateReadWriteEntity("DLP1A.DLP1A.TO" + i, 0));
        }
        list.add(generateReadWriteEntity("DLP1A.DLP1A.MesReply", 0));
        miloService.writeToOpcWord(list);
//        List<ReadWriteEntity> list = new ArrayList<>();
//        for (int i = 1; i <= 6; i++) {
//            list.add(generateReadWriteEntity("DLP1A.DLP1A.TO" + i, 0));
//        }
//        list.add(generateReadWriteEntity("DLP1A.DLP1A.MesReply", 0));
//        miloService.writeToOpcWord(list);
        s7DataDLPOne =new S7DataDLPOne();
        s7DataDLPOne.setTo1((short)0);
        s7DataDLPOne.setTo2((short)0);
        s7DataDLPOne.setTo3((short)0);
        s7DataDLPOne.setTo4((short)0);
        s7DataDLPOne.setTo5((short)0);
        s7DataDLPOne.setTo6((short)0);
        s7DataDLPOne.setMesReply((short)0);
        s7SerializerDLPOne.write(s7DataDLPOne);
    }

    @Scheduled(fixedDelay = 1000)
    public void finishOutBigStorageTask() throws Exception {
        ReadWriteEntity inkageEntity = miloService.readFromOpcUa("DLP1B.DLP1B.mesControl");
        if (true != Boolean.parseBoolean(inkageEntity.getValue() + "")) {
        S7DataDLPTwo s7DataWLTwo = s7SerializerDLPTwo.read(S7DataDLPTwo.class);
//        ReadWriteEntity inkageEntity = miloService.readFromOpcUa("DLP1B.DLP1B.mesControl");
//        if (true != Boolean.parseBoolean(inkageEntity.getValue() + "")) {
        Boolean inkageEntity = s7DataWLTwo.getMesControl();
        if (true != inkageEntity) {
            log.info("当前为非联机状态，结束完成出片任务");
            return;
        }
@@ -533,6 +682,10 @@
                    bigStorageCageDetailsService.updateBySlot(storageCageDTOList, Const.GLASS_STATE_OUT);
                } else {
                    bigStorageCageDetailsService.updateBySlot(storageCageDTOList, Const.GLASS_STATE_IN);
                    //按照格子信息更新对应的设备id
                    List<Integer> slotList = storageCageDTOList.stream().map(UpdateBigStorageCageDTO::getTargetSlot).distinct().collect(Collectors.toList());
                    bigStorageCageDetailsService.updateDeviceIdBySlot(slotList);

                }
                log.info("4、大理片笼进片状态已完成已完成的玻璃信息id:{}", v);
                updateSlotRemainBySlots(outSuccessGlassSlot);
@@ -569,7 +722,10 @@
        bigStorageCageTaskService.updateOutTaskMessage("big_storage_cage_out_one_task");
        //清空启动状态
        //向opc发送启动信号
        miloService.writeToOpcWord(generateReadWriteEntity("DLP1B.DLP1B.MesReply", 0));
//        miloService.writeToOpcWord(generateReadWriteEntity("DLP1B.DLP1B.MesReply", 0));
        S7DataDLPTwo s7DataDLPTwo=new S7DataDLPTwo();
        s7DataDLPTwo.setMesReply((short)0);
        s7SerializerDLPTwo.write(s7DataDLPTwo);
    }

    private void dealDamageInTask(List<BigStorageCageTask> damageTaskList) {
@@ -682,9 +838,18 @@
     */
    private <T extends BigStorageCageBaseInfo> Boolean computeOutGlassInfoByVirtualSlot(List<T> list, String tableName, int targetSlot, int state, int taskType) {
        //任务数据:获取车子存放玻璃最大数量,玻璃间隔
        List<String> glassIdList = bigStorageGlassRelationInfoService.queryNeedOutGlassId(
                list.get(0).getEngineerId(), list.get(0).getTemperingLayoutId(), list.get(0).getTemperingFeedSequence());
        List<T> outGlassList = list.stream().filter(e -> glassIdList.contains(e.getGlassId())).collect(Collectors.toList());
        List<T> outGlassList = list;
        if (!THROUGH_SLOT.equals(list.get(0).getSlot())) {
            //todo:临时解决方案:出片时考虑玻璃碰撞，改为一片一出
            // 界面关闭调度开关 !Const.BIG_STORAGE_BEFORE_DISPATCH.equals(taskType)
            if (list.get(0).getThickness() >= 8) {
                outGlassList = list.subList(0, 1);
            } else {
                List<String> glassIdList = bigStorageGlassRelationInfoService.queryNeedOutGlassId(
                        list.get(0).getEngineerId(), list.get(0).getTemperingLayoutId(), list.get(0).getTemperingFeedSequence());
                outGlassList = list.stream().filter(e -> glassIdList.contains(e.getGlassId())).collect(Collectors.toList());
            }
        }
        Assert.isFalse(CollectionUtil.isEmpty(outGlassList), "未获取出片数据，结束出片任务");
        log.info("获取出片任务数据{}条，执行保存", outGlassList.size());
        List<BigStorageCageTask> bigStorageCageTaskList = outGlassList.stream()
@@ -715,7 +880,10 @@
                .ne(BigStorageCageDetails::getState, Const.GLASS_STATE_OUT)
                .in(BigStorageCageDetails::getGlassId, glassIds));
        try {
            miloService.writeToOpcWord(generateReadWriteEntity("DLP1B.DLP1B.MesReply", 1));
//            miloService.writeToOpcWord(generateReadWriteEntity("DLP1B.DLP1B.MesReply", 1));
            S7DataDLPTwo s7DataDLPTwo=new S7DataDLPTwo();
            s7DataDLPTwo.setMesReply((short)1);
            s7SerializerDLPTwo.write(s7DataDLPTwo);
        } catch (Exception e) {
            e.printStackTrace();
        }
@@ -733,7 +901,9 @@
        //任务数据:获取车子存放玻璃最大数量,玻璃间隔
        List<BigStorageCageTask> bigStorageCageTaskList = new ArrayList<>();
        //打车剩余尺寸
        Integer remainWidth = carWidth;
        Integer outCarMaxSize = sysConfigService.queryConfigValue(ConstSysConfig.VERTICAL_OUT_CAR_SIZE);
        Integer glassGap = sysConfigService.queryConfigValue(ConstSysConfig.VERTICAL_GLASS_GAP);
        Integer remainWidth = sysConfigService.queryConfigValue(ConstSysConfig.VERTICAL_CAR_WIDTH);
        for (T e : list) {
            if (bigStorageCageTaskList.size() >= outCarMaxSize || Math.max((int) e.getWidth(), (int) e.getHeight()) > remainWidth) {
                break;
@@ -770,7 +940,10 @@
                .set(Const.GLASS_STATE_SCHEDULE_ING.equals(state), BigStorageCageBaseInfo::getSlot, targetSlot)
                .in(BigStorageCageDetails::getGlassId, glassIds));
        try {
            miloService.writeToOpcWord(generateReadWriteEntity("DLP1B.DLP1B.MesReply", 1));
//            miloService.writeToOpcWord(generateReadWriteEntity("DLP1B.DLP1B.MesReply", 1));
            S7DataDLPTwo s7DataDLPTwo=new S7DataDLPTwo();
            s7DataDLPTwo.setMesReply((short)1);
            s7SerializerDLPTwo.write(s7DataDLPTwo);
        } catch (Exception e) {
            e.printStackTrace();
        }
@@ -783,6 +956,8 @@
        List<BigStorageCageDetails> inSlotGlassList = bigStorageCageDetailsService.list(new LambdaQueryWrapper<BigStorageCageDetails>()
                .in(BigStorageCageDetails::getSlot, slotList).in(BigStorageCageDetails::getState, Const.GLASS_STATE_IN_ALL));
        Map<Integer, Double> slotRemainMap = new HashMap<>();
        Integer glassGap = sysConfigService.queryConfigValue(ConstSysConfig.VERTICAL_GLASS_GAP);
        Integer slotWidth = sysConfigService.queryConfigValue(ConstSysConfig.VERTICAL_SLOT_WIDTH);
        //是否存在有格子非空的玻璃
        if (CollectionUtil.isNotEmpty(inSlotGlassList)) {
            //存在  将格子内的玻璃分别进行更新