S7通讯部署版本代码提交

ZengTao

2025-06-18 cfaa77861170237f07da3113c7d505c70bf371be

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

@@ -6,6 +6,8 @@
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.base.entity.HollowBigStorageCageBaseInfo;
@@ -33,6 +35,9 @@
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;
@@ -41,6 +46,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.Qualifier;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

@@ -79,6 +85,22 @@
    @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;

    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";
    /**
@@ -109,33 +131,48 @@

    @Scheduled(fixedDelay = 1000)
    public void inBigStorageTask() throws Exception {
        ReadWriteEntity inkageEntity = miloService.readFromOpcUa("DLP2A.DLP2A.mesControl");
        if (true != Boolean.parseBoolean(inkageEntity.getValue() + "")) {
        S7DataZKDLPOne s7DataZKDLPOne = s7SerializerZKDLPOne.read(S7DataZKDLPOne.class);
        log.info("进片任务读取s7DataZKDLPOne:{}", s7DataZKDLPOne);
//        ReadWriteEntity inkageEntity = miloService.readFromOpcUa("DLP2A.DLP2A.mesControl");
//        if (true != Boolean.parseBoolean(inkageEntity.getValue() + "")) {
        Boolean inkageEntity = s7DataZKDLPOne.getMesControl();
        if (true != inkageEntity) {
            log.info("当前为非联机状态，结束进片任务");
            return;
        }
        ReadWriteEntity requestEntity = miloService.readFromOpcUa("DLP2A.DLP2A.RequestMes");
        if (!"1".equals(requestEntity.getValue() + "")) {
//        ReadWriteEntity requestEntity = miloService.readFromOpcUa("DLP2A.DLP2A.RequestMes");
//        if (!"1".equals(requestEntity.getValue() + "")) {
        String requestEntity = s7DataZKDLPOne.getRequestMes().toString();
        if (!"1".equals(requestEntity)) {
            log.info("当前未收到进片请求，结束进片任务");
            return;
        }
        ReadWriteEntity mesReplyEntity = miloService.readFromOpcUa("DLP2A.DLP2A.MesReply");
        if ("1".equals(mesReplyEntity.getValue() + "")) {
//        ReadWriteEntity mesReplyEntity = miloService.readFromOpcUa("DLP2A.DLP2A.MesReply");
//        if ("1".equals(mesReplyEntity.getValue() + "")) {
        String mesReplyEntity = s7DataZKDLPOne.getMesReply().toString();
        if ("1".equals(mesReplyEntity)) {
            log.info("有正在执行的任务，结束进片任务");
            return;
        }

        List<BigStorageCageTask> inTaskList = new ArrayList();
        ReadWriteEntity fromOpcUa = miloService.readFromOpcUa("DLP2A.DLP2A.FROM1");
//        ReadWriteEntity fromOpcUa = miloService.readFromOpcUa("DLP2A.DLP2A.FROM1");
        String fromOpcUa = s7DataZKDLPOne.getFrom1().toString();
        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()) {
//            ReadWriteEntity requestWord = miloService.readFromOpcUa("DLP2A.DLP2A.DI" + i);
            String requestWord = requestWords.get(i - 1);
//            if (null != requestWord.getValue()) {
            if (null != requestWord && !requestWord.isEmpty()) {
                BigStorageCageTask task = new BigStorageCageTask();
                task.setGlassId(requestWord.getValue() + "");
                task.setStartSlot(Integer.parseInt(fromOpcUa.getValue() + ""));
//                task.setGlassId(requestWord.getValue() + "");
                task.setGlassId(requestWord.toString());
//                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.toString());
                continue;
            }
        }
@@ -149,7 +186,10 @@
            if (entry.getValue() > 1) {
                log.info("进片玻璃{}存在相同，结束本次任务", entry.getKey());
                //向plc发送报警:同一车进片玻璃存在相同
                miloService.writeToOpcWord(generateReadWriteEntity("DLP2A.DLP2A.alarmSignal", 2));
//                miloService.writeToOpcWord(generateReadWriteEntity("DLP2A.DLP2A.alarmSignal", 2));
                s7DataZKDLPOne = new S7DataZKDLPOne();
                s7DataZKDLPOne.setAlramSignal(2);
                s7SerializerZKDLPOne.write(s7DataZKDLPOne);
                return;
            }
        }
@@ -158,7 +198,10 @@
        if (CollectionUtil.isNotEmpty(detailsList)) {
            log.info("理片笼存在相同的进片玻璃{}，结束本次任务", detailsList);
            //向plc发送报警:理片笼存在相同的进片玻璃
            miloService.writeToOpcWord(generateReadWriteEntity("DLP2A.DLP2A.alarmSignal", 4));
//            miloService.writeToOpcWord(generateReadWriteEntity("DLP2A.DLP2A.alarmSignal", 4));
            s7DataZKDLPOne = new S7DataZKDLPOne();
            s7DataZKDLPOne.setAlramSignal(4);
            s7SerializerZKDLPOne.write(s7DataZKDLPOne);
            return;
        }
        List<GlassInfo> glassInfoList = glassInfoService.list(new LambdaQueryWrapper<GlassInfo>().in(GlassInfo::getGlassId, glassIdList));
@@ -166,7 +209,10 @@
        if (glassInfoList.size() != inTaskList.size()) {
            log.info("进片任务数量{}与玻璃数量{}不匹配，结束本次进片", inTaskList.size(), glassInfoList.size());
            //向plc发送报警:进片任务数量与系统查询到的玻璃数量不匹配
            miloService.writeToOpcWord(generateReadWriteEntity("DLP2A.DLP2A.alarmSignal", 8));
//            miloService.writeToOpcWord(generateReadWriteEntity("DLP2A.DLP2A.alarmSignal", 8));
            s7DataZKDLPOne = new S7DataZKDLPOne();
            s7DataZKDLPOne.setAlramSignal(8);
            s7SerializerZKDLPOne.write(s7DataZKDLPOne);
            return;
        }

@@ -181,7 +227,10 @@
            if (count < entry.getValue()) {
                log.info("笼内格子剩余数量不足，结束本次进片");
                //向plc发送报警:笼内格子剩余数量不足
                miloService.writeToOpcWord(generateReadWriteEntity("DLP2A.DLP2A.alarmSignal", 16));
//                miloService.writeToOpcWord(generateReadWriteEntity("DLP2A.DLP2A.alarmSignal", 16));
                s7DataZKDLPOne = new S7DataZKDLPOne();
                s7DataZKDLPOne.setAlramSignal(16);
                s7SerializerZKDLPOne.write(s7DataZKDLPOne);
                return;
            }
        }
@@ -195,7 +244,10 @@
            if (count > 0) {
                log.info("直通片台存在玻璃，结束本次进片");
                //向plc发送报警:直通片台存在玻璃，无法继续直通
                miloService.writeToOpcWord(generateReadWriteEntity("DLP2A.DLP2A.alarmSignal", 64));
//                miloService.writeToOpcWord(generateReadWriteEntity("DLP2A.DLP2A.alarmSignal", 64));
                s7DataZKDLPOne = new S7DataZKDLPOne();
                s7DataZKDLPOne.setAlramSignal(64);
                s7SerializerZKDLPOne.write(s7DataZKDLPOne);
                return;
            }
        }
@@ -227,7 +279,7 @@
                            .eq(HollowBigStorageCage::getSlot, bigStorageDTO.getSlot()));
                    task.setTargetSlot(bigStorageDTO.getSlot());
                    task.setGlassId(info.getGlassId());
                    bigStorageCageTaskService.updateTaskMessage(BIG_STORAGE_CAGE_IN_TWO_TASK, task);
//                    bigStorageCageTaskService.updateTaskMessage(BIG_STORAGE_CAGE_IN_TWO_TASK, task);
                    //存放历史任务
                    HollowBigStorageCageHistoryTask historyTask = new HollowBigStorageCageHistoryTask();
                    BeanUtils.copyProperties(task, historyTask);
@@ -260,7 +312,7 @@
            } else {
                BigStorageCageTask task = inTaskList.get(0);
                task.setTargetSlot(THROUGH_SLOT);
                bigStorageCageTaskService.updateTaskMessage("big_storage_cage_in_two_task", task);
//                bigStorageCageTaskService.updateTaskMessage("big_storage_cage_in_two_task", task);
                //存放历史任务
                HollowBigStorageCageHistoryTask historyTask = new HollowBigStorageCageHistoryTask();
                BeanUtils.copyProperties(task, historyTask);
@@ -295,49 +347,102 @@
        //历史数据入库
        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()));
//        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()));
//        }
//        list.add(generateReadWriteEntity("DLP2A.DLP2A.MesReply", 1));
//        miloService.writeToOpcWord(list);
        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);
//        ReadWriteEntity inkageEntity = miloService.readFromOpcUa("DLP2B.DLP2B.mesControl");
//        if (true != Boolean.parseBoolean(inkageEntity.getValue() + "")) {
        Boolean inkageEntity = s7DataZKDLPTwo.getMesControl();
        if (true != inkageEntity) {
            log.info("当前为非联机状态，结束进片任务");
            return;
        }
        ReadWriteEntity requestEntity = miloService.readFromOpcUa("DLP2B.DLP2B.RequestMes");
        if (!"1".equals(requestEntity.getValue() + "")) {
//        ReadWriteEntity requestEntity = miloService.readFromOpcUa("DLP2B.DLP2B.RequestMes");
//        if (!"1".equals(requestEntity.getValue() + "")) {
        String requestEntity = s7DataZKDLPTwo.getRequestMes().toString();
        if (!"1".equals(requestEntity)) {
            log.info("当前未收到出片请求，结束出片任务");
            return;
        }
        //获取出片任务表
        List<BigStorageCageTask> outTaskList = bigStorageCageTaskService.queryTaskMessage(BIG_STORAGE_CAGE_OUT_TWO_TASK);
//        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, ReadWriteEntity> map = new HashMap<>();
        ReadWriteEntity oneEntity = miloService.readFromOpcUa("CMJ1.CMJ1.isFree");
        ReadWriteEntity twoEntity = miloService.readFromOpcUa("ZKQ2.ZKQ2.isFree");
        ReadWriteEntity threeEntity = miloService.readFromOpcUa("ZKQ2.ZKQ2.isFree03");
        map.put(930, oneEntity);
        map.put(931, twoEntity);
        map.put(932, threeEntity);
        HashMap<Integer, Boolean> map = new HashMap<>();
        try {
            if (CMJ1ModbusTcp.checkConnected()) {
                Boolean oneEntity = CMJ1ModbusTcp.readUInt16(42027 - 40001) != 0;
                map.put(930, oneEntity);
            } 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("二/三线线空闲状态获取异常");
        }
        HollowGlassOutRelationInfo hollowGlassOutRelationInfo = null;
        int cell = -1;
        for (int i = 930; i <= 932; i++) {
            if (null == hollowGlassOutRelationInfo) {
                ReadWriteEntity entity = map.get(i);
                Boolean entity = map.get(i);
                cell = i;
                if (null != entity.getValue() && ("1".equals(entity.getValue() + "") || Boolean.parseBoolean(entity.getValue() + ""))) {
//                if (null != entity.getValue() && ("1".equals(entity.getValue() + "") || Boolean.parseBoolean(entity.getValue() + ""))) {
                if (null != entity && entity) {
                    hollowGlassOutRelationInfo = hollowGlassOutRelationInfoService
                            .getOne(new LambdaQueryWrapper<HollowGlassOutRelationInfo>()
                                    .eq(HollowGlassOutRelationInfo::getCell, cell)
@@ -427,33 +532,86 @@

    @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);
//        ReadWriteEntity inkageEntity = miloService.readFromOpcUa("DLP2A.DLP2A.mesControl");
//        if (true != Boolean.parseBoolean(inkageEntity.getValue() + "")) {
        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() + "")) {
//        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);
//            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.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;
            }
        }
@@ -525,30 +683,45 @@
                    .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);
//        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);
//        ReadWriteEntity inkageEntity = miloService.readFromOpcUa("DLP2B.DLP2B.mesControl");
//        if (true != Boolean.parseBoolean(inkageEntity.getValue() + "")) {
        Boolean inkageEntity = s7DataZKDLPTwo.getMesControl();
        if (true != inkageEntity) {
            log.info("当前为非联机状态，结束完成出片任务");
            return;
        }
        //获取进片任务表
        List<BigStorageCageTask> outTaskList = bigStorageCageTaskService.queryTaskMessage(BIG_STORAGE_CAGE_OUT_TWO_TASK);
        //获取出片任务表
//        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());
@@ -569,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());
@@ -597,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) {
                //破损处理
@@ -664,11 +837,14 @@
        }

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

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

    private void dealDamageInTask(List<BigStorageCageTask> damageTaskList) {
@@ -804,7 +980,10 @@

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

@@ -881,12 +1060,58 @@
        for (T t : baseInfoList) {
            bigStorageCageTaskList.add(new BigStorageCageTask(t.getGlassId(), t.getSlot(), targetSlot, 0));
        }
        while (bigStorageCageTaskList.size() < 6) {
            bigStorageCageTaskList.add(new BigStorageCageTask("", 0, 0, 0));
        }
//        while (bigStorageCageTaskList.size() < 6) {
//            bigStorageCageTaskList.add(new BigStorageCageTask("", 0, 0, 0));
//        }
        //清空任务表数据
        bigStorageCageTaskService.removeAll(tableName);
        bigStorageCageTaskService.saveTaskMessage(tableName, bigStorageCageTaskList);
        resetOutTask();
//        bigStorageCageTaskService.removeAll(tableName);
//        bigStorageCageTaskService.saveTaskMessage(tableName, bigStorageCageTaskList);
        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);
@@ -894,6 +1119,7 @@
            history.setTaskType(taskType);
            return history;
        }).collect(Collectors.toList());
        log.info("历史任务保存{}", historyList);
        hollowBigStorageCageHistoryTaskService.saveBatch(historyList);
        log.info("将出片玻璃{}玻璃状态改为出片中", glassIds);
        hollowBigStorageCageDetailsService.update(new LambdaUpdateWrapper<HollowBigStorageCageDetails>()
@@ -902,7 +1128,11 @@
                .ne(HollowBigStorageCageDetails::getState, Const.GLASS_STATE_OUT)
                .in(HollowBigStorageCageDetails::getGlassId, glassIds));
        try {
            miloService.writeToOpcWord(generateReadWriteEntity("DLP2B.DLP2B.MesReply", 1));

//            miloService.writeToOpcWord(generateReadWriteEntity("DLP2B.DLP2B.MesReply", 1));
            s7DataZKDLPTwo = new S7DataZKDLPTwo();
            s7DataZKDLPTwo.setMesReply(1);
            s7SerializerZKDLPTwo.write(s7DataZKDLPTwo);
        } catch (Exception e) {
            e.printStackTrace();
        }
@@ -946,4 +1176,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);
    }
}