Merge branch 'master' of http://10.153.19.25:10105/r/YiWuProject

wangfei

2025-07-10 3df859f5bf52a1e80c7dc2ac2a2e5386142ab2c3

Merge branch 'master' of http://10.153.19.25:10105/r/YiWuProject

 hangzhoumesParent/common/pom.xml

@@ -163,7 +163,7 @@
        <dependency>
            <groupId>com.github.xingshuangs</groupId>
            <artifactId>iot-communication</artifactId>
            <version>1.4.2</version>
            <version>1.5.4</version>
        </dependency>

        <!--引入redis,排除lettuce的引用-->

 hangzhoumesParent/common/servicebase/src/main/java/com/mes/common/config/Const.java

@@ -36,10 +36,10 @@
     * 忙碌 1
     * 禁用 2
     */
    public static final String OUT_FREE = "0";
    public static final String OUT_BUSY = "1";
    public static final String OUT_DISABLE = "2";
    public static final List<String> OUT_DISABLE_ALL = Arrays.asList("1", "2");
    public static final Integer OUT_FREE = 0;
    public static final Integer OUT_BUSY = 1;
    public static final Integer OUT_DISABLE = 2;
    public static final List<Integer> OUT_DISABLE_ALL = Arrays.asList(1, 2);


    /**

 hangzhoumesParent/common/servicebase/src/main/java/com/mes/pp/service/impl/OptimizeHeatLayoutServiceImpl.java

@@ -32,7 +32,7 @@
    public OptimizeHeatLayout selectHeatLayoutInfo(String engineerId, Integer temperingid) {

        QueryWrapper<OptimizeHeatLayout> wrapper = new QueryWrapper<>();
        wrapper.select("Top 1 *").eq("project_no", engineerId)
        wrapper.eq("project_no", engineerId)
                .eq("layout_id", temperingid);
        return baseMapper.selectOne(wrapper);
    }

 hangzhoumesParent/common/servicebase/src/main/java/com/mes/temperingglass/mapper/TemperingGlassInfoMapper.java

@@ -44,4 +44,6 @@
            "WHERE\n" +
            "\tCONVERT ( DATE, create_time ) = CONVERT ( DATE, getdate( ) )")
    List<PieChartVO> queryPieChart();

    List<TemperingGlassInfo> queryEngineerAndLayoutId();
}

 hangzhoumesParent/common/servicebase/src/main/java/com/mes/temperingglass/service/TemperingGlassInfoService.java

@@ -79,4 +79,6 @@
     * @return
     */
    List<PieChartVO> queryPieChart();

    List<TemperingGlassInfo> queryEngineerAndLayoutId();
}

 hangzhoumesParent/common/servicebase/src/main/java/com/mes/temperingglass/service/impl/TemperingGlassInfoServiceImpl.java

@@ -207,4 +207,9 @@
    public List<PieChartVO> queryPieChart() {
        return baseMapper.queryPieChart();
    }

    @Override
    public List<TemperingGlassInfo> queryEngineerAndLayoutId() {
        return baseMapper.queryEngineerAndLayoutId();
    }
}

 hangzhoumesParent/common/servicebase/src/main/resources/mapper/OrderMapper.xml

@@ -17,7 +17,8 @@
               a.area,
               a.quantity,
               a.create_time,
               round(ifnull(d.finishNum, 0) / a.quantity * 100) as 'percent'
               round(ifnull(d.finishNum, 0) / a.quantity * 100) as 'percent',
                ifnull(d.finishNum, 0)
        from sd.`order` as a
                 LEFT JOIN (
            SELECT sum(c.reporting_work_num) as 'finishNum',order_id
@@ -28,6 +29,7 @@
            GROUP BY c.order_id
        ) as d
                           on a.order_id = d.order_id
        where a.warehousing != 2 and a.warehousing > 0
        where a.warehousing != 2 and a.warehousing >= 0
        ORDER BY  a.order_id desc
    </select>
</mapper>

 hangzhoumesParent/common/servicebase/src/main/resources/mapper/TemperingGlassInfoMapper.xml

@@ -1,6 +1,11 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.mes.temperingglass.mapper.TemperingGlassInfoMapper">

    <resultMap id="baseMap" type="com.mes.temperingglass.entity.TemperingGlassInfo">
        <result column="engineer_id" property="engineerId"/>
        <result column="tempering_layout_id" property="temperingLayoutId"/>
    </resultMap>
    <insert id="saveBatch">
        INSERT INTO tempering_glass_info (glass_id, flow_card_id, glass_type, width, height, thickness, films_id,
        ishorizontal, tempering_layout_id,
@@ -12,5 +17,12 @@
            #{item.angle}, #{item.state}, #{item.slot}, #{item.engineerId}, 0)
        </foreach>
    </insert>
    <select id="queryEngineerAndLayoutId" resultMap="baseMap">
        select top 3 engineer_id,tempering_layout_id
        from tempering_glass_info
        where state = 1 and deleted = 0
        group by engineer_id, tempering_layout_id
        order by min(id) desc
    </select>

</mapper>

 hangzhoumesParent/moduleService/CacheGlassModule/src/main/java/com/mes/config/S7Config.java

New file
@@ -0,0 +1,49 @@
package com.mes.config;

import com.github.xingshuangs.iot.protocol.s7.enums.EPlcType;
import com.github.xingshuangs.iot.protocol.s7.serializer.S7Serializer;
import com.github.xingshuangs.iot.protocol.s7.service.S7PLC;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @Author : zhoush
 * @Date: 2025/4/30 13:50
 * @Description:
 */
@Configuration
public class S7Config {
    @Bean(name = "s7SerializerWLOne")
    public S7Serializer s7SerializerWLOne() {
        S7PLC s7PLC = new S7PLC(EPlcType.S1200, "192.168.10.100");
//        S7PLC s7PLC = new S7PLC(EPlcType.S1500, "10.153.19.191");
        return S7Serializer.newInstance(s7PLC);
    }

    @Bean(name = "s7SerializerWLTwo")
    public S7Serializer s7SerializerWLTwo() {
        S7PLC s7PLC = new S7PLC(EPlcType.S1200, "192.168.10.130");
//        S7PLC s7PLC = new S7PLC(EPlcType.S1500, "10.153.19.191");
        return S7Serializer.newInstance(s7PLC);
    }

    @Bean(name = "s7SerializerMBOne")
    public S7Serializer s7SerializerMBOne() {
        S7PLC s7PLC = new S7PLC(EPlcType.S1200, "192.168.10.58");
//        S7PLC s7PLC = new S7PLC(EPlcType.S1500, "10.153.19.191");
        return S7Serializer.newInstance(s7PLC);
    }

    @Bean(name = "s7SerializerMBTwo")
    public S7Serializer s7SerializerMBTwo() {
        S7PLC s7PLC = new S7PLC(EPlcType.S1200, "192.168.10.18");
//        S7PLC s7PLC = new S7PLC(EPlcType.S1500, "10.153.19.191");
        return S7Serializer.newInstance(s7PLC);
    }

    @Bean(name = "s7SerializerMBExtra")
    public S7Serializer s7SerializerMBExtra() {
        S7PLC s7PLC = new S7PLC(EPlcType.S1500, "192.168.20.100");
        return S7Serializer.newInstance(s7PLC);
    }
}

 hangzhoumesParent/moduleService/CacheGlassModule/src/main/java/com/mes/job/OpcCacheGlassNewTask.java

@@ -5,6 +5,7 @@
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.github.xingshuangs.iot.protocol.s7.serializer.S7Serializer;
import com.kangaroohy.milo.model.ReadWriteEntity;
import com.kangaroohy.milo.service.MiloService;
import com.mes.common.config.Const;
@@ -18,20 +19,22 @@
import com.mes.edgstoragecage.service.EdgStorageCageService;
import com.mes.glassinfo.entity.GlassInfo;
import com.mes.glassinfo.service.GlassInfoService;
import com.mes.opctask.entity.EdgStorageDeviceTask;
import com.mes.opctask.entity.EdgStorageDeviceTaskHistory;
import com.mes.opctask.service.EdgStorageDeviceTaskHistoryService;
import com.mes.opctask.service.EdgStorageDeviceTaskService;
import com.mes.s7.entity.S7DataMB;
import com.mes.s7.entity.S7DataWL;
import com.mes.s7.entity.S7DataWLExtra;
import com.mes.sysconfig.service.SysConfigService;
import lombok.extern.slf4j.Slf4j;
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;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

@@ -68,32 +71,41 @@
    @Resource
    SysConfigService sysConfigService;

    //    @Value("${mes.threshold}")
    @Autowired
    @Qualifier("s7SerializerWLOne")
    private S7Serializer s7SerializerWLOne;

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

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

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


    private int threshold;
    //    @Value("${mes.cellLength}")

    private int cellLength;
    //    @Value("${mes.ratio}")

    private int ratio;

    //    @Value("${mes.min.one.firstLength}")
    private int minOneFirstLength;
    //
//    @Value("${mes.min.one.secondLength}")

    private int minOneSecondLength;
    //
//    @Value("${mes.min.two.firstLength}")

    private int minTwoFirstLength;
    //
//    @Value("${mes.min.two.secondLength}")

    private int minTwoSecondLength;
    //
//    @Value("${mes.max.firstLength}")

    private int maxTwoFirstLength;
    //
//    @Value("${mes.max.secondLength}")

    private int maxTwoSecondLength;
    //
//    @Value("${mes.maxThickness}")

    private int maxThickness;

    private String glassInIdOne = "";
@@ -103,28 +115,36 @@

    @Scheduled(fixedDelay = 1000)
    public void startOneOpcTask() throws Exception {
        S7DataWL s7DataWLTwo = s7SerializerWLTwo.read(S7DataWL.class);
        S7DataWL s7DataWLOne = s7SerializerWLOne.read(S7DataWL.class);
        S7DataWLExtra s7DataWLExtraTwo = s7SerializerWLTwo.read(S7DataWLExtra.class);
        log.info("一线卧理: {}", s7DataWLOne);
        //获取第二条线路的卧式理片笼状态
        ReadWriteEntity twoInkageEntity = miloService.readFromOpcUa("WL2.WL2.deviceState");
        Boolean twoInkageEntity = s7DataWLTwo.getDeviceState();
        //默认只跑一台卧式理片,两条线路都可以走
        int cellFlag = 1;
        //如果两条线都启动则只能跑一条线
        if (twoInkageEntity != null && !Boolean.parseBoolean(twoInkageEntity.getValue() + "")) {
        if (!twoInkageEntity && !Const.OUT_DISABLE.equals(s7DataWLExtraTwo.getD06SlotState())) {
            cellFlag = 2;
        }
        startOneOpcTaskChild(EDG_STORAGE_DEVICE_ONE_TASK, 1, cellFlag);
        startOneOpcTaskChild(s7DataWLOne, 1, cellFlag);
    }

    @Scheduled(fixedDelay = 1000)
    public void startTwoOpcTask() throws Exception {
        ReadWriteEntity oneInkageEntity = miloService.readFromOpcUa("WL1.WL1.deviceState");
        S7DataWL s7DataWLOne = s7SerializerWLOne.read(S7DataWL.class);
        S7DataWL s7DataWLTwo = s7SerializerWLTwo.read(S7DataWL.class);
        S7DataWLExtra s7DataWLExtraTwo = s7SerializerWLTwo.read(S7DataWLExtra.class);
        log.info("二线卧理: {}", s7DataWLTwo);
        Boolean oneInkageEntity = s7DataWLOne.getDeviceState();
        int cellFlag = 1;
        if (oneInkageEntity != null && !Boolean.parseBoolean(oneInkageEntity.getValue() + "")) {
        if (!oneInkageEntity  && !Const.OUT_DISABLE.equals(s7DataWLExtraTwo.getD06SlotState())) {
            cellFlag = 2;
        }
        startOneOpcTaskChild(EDG_STORAGE_DEVICE_TWO_TASK, 2, cellFlag);
        startOneOpcTaskChild(s7DataWLTwo, 2, cellFlag);
    }

    private void startOneOpcTaskChild(String tableName, int device, int cellFlag) throws Exception {
    private void startOneOpcTaskChild(S7DataWL task, int device, int cellFlag) throws Exception {
        threshold = sysConfigService.queryConfigValue(ConstSysConfig.CACHE_THRESHOLD);
        cellLength = sysConfigService.queryConfigValue(ConstSysConfig.CACHE_CELL_LENGTH);
        ratio = sysConfigService.queryConfigValue(ConstSysConfig.CACHE_RATIO);
@@ -136,7 +156,7 @@
        maxTwoSecondLength = sysConfigService.queryConfigValue(ConstSysConfig.CACHE_MAX_SECOND_LENGTH);
        maxThickness = sysConfigService.queryConfigValue(ConstSysConfig.CACHE_MAX_THICKNESS);

        EdgStorageDeviceTask task = edgStorageDeviceTaskService.queryTaskMessage(tableName);

        if (task == null) {
            log.info("任务表基础数据录入失败，请检查数据是否录入成功");
            return;
@@ -155,44 +175,43 @@
            //进片任务
            log.info("设备：{}状态：{}", device, request);
            log.info("进片任务：进片玻璃id为：{}", task.getGlassIdIn());
            intoTask(task, tableName, device);
            intoTask(task, device);
        } else if (request == 2 && taskRunning == 0) {
            //出片任务
            outTask(task, tableName, device, cellFlag);
            outTask(task, device, cellFlag);
        } else if (request == 3 && taskRunning == 0) {
            //直通任务
            log.info("设备：{}状态：{}", device, request);
            if (!outTask(task, tableName, device, cellFlag)) {
                intoTask(task, tableName, device);
            if (!outTask(task, device, cellFlag)) {
                intoTask(task, device);
            }
        } else if (request == 4) {
            log.info("设备：{}状态：{}", device, request);
            log.info("将启动子改为4");
            task.setTaskRunning(Const.GLASS_CACHE_TYPE_RUNNING);
            edgStorageDeviceTaskService.updateTaskMessage(tableName, task);
            if (device == 2) {
                task.setTaskRunning(Const.GLASS_CACHE_TYPE_RUNNING);
                s7SerializerWLTwo.write(S7DataWL.builder().taskRunning(Const.GLASS_CACHE_TYPE_RUNNING).build());
            } else {
                task.setTaskRunning(Const.GLASS_CACHE_TYPE_RUNNING);
                s7SerializerWLOne.write(S7DataWL.builder().taskRunning(Const.GLASS_CACHE_TYPE_RUNNING).build());
            }

        } else if (request == 5) {
            log.info("设备：{}状态：{}", device, request);
            finishTask(task, tableName, device);
            finishTask(task, "", device);
        } else {
            log.info("玻璃异常处理");
            damageTask(task, tableName, device);
            damageTask(task, "", device);
        }
//    } catch(Exception e)
//
//    {
//        log.info("执行任务过程中发生异常，任务字{}，{}", task.getTaskState(), e.getMessage());
//        log.info("将启动字改为0");
//        task.setTaskRunning(Const.GLASS_CACHE_TYPE_EMPTY);
//        edgStorageDeviceTaskService.updateTaskMessage(tableName, task);
//    }

    }


    @Scheduled(fixedDelay = 1000)
    public void edgOneOpcTask() throws Exception {
        EdgStorageDeviceTask task = edgStorageDeviceTaskService.queryTaskMessage(EDG_STORAGE_DEVICE_ONE_TASK);
        String glassId = task.getGlassId();
        S7DataWL s7DataWLOne = s7SerializerWLOne.read(S7DataWL.class);
        String glassId = s7DataWLOne.getGlassId();
        log.info("1号线玻璃id{},历史id{}", glassId, glassIdOne);
        if (StringUtils.isBlank(glassId) || glassId.equals(glassIdOne)) {
            log.info("{}号线磨边前玻璃未就位，结束本次任务", 1);
            return;
@@ -201,9 +220,10 @@
    }

    @Scheduled(fixedDelay = 1000)
    public void edgTwoOpcTask() throws Exception {
        EdgStorageDeviceTask task = edgStorageDeviceTaskService.queryTaskMessage(EDG_STORAGE_DEVICE_TWO_TASK);
        String glassId = task.getGlassId();
    public void edgTwoOpcTask() {
        S7DataWL s7DataWLTwo = s7SerializerWLTwo.read(S7DataWL.class);
        String glassId = s7DataWLTwo.getGlassId();
        log.info("2号线玻璃id{},历史id{}", glassId, glassIdTwo);
        if (StringUtils.isBlank(glassId) || glassId.equals(glassIdTwo)) {
            log.info("{}号线磨边前玻璃未就位，结束本次任务", 2);
            return;
@@ -211,7 +231,7 @@
        edgTaskChild(glassId, 2);
    }

    private void edgTaskChild(String glassId, int cell) throws Exception {
    private void edgTaskChild(String glassId, int cell) {
        ratio = sysConfigService.queryConfigValue(ConstSysConfig.CACHE_RATIO);
        GlassInfo glassInfo = glassInfoService.getOne(new LambdaQueryWrapper<GlassInfo>().eq(GlassInfo::getGlassId, glassId).last("limit 1"));
        if (glassInfo == null) {
@@ -219,15 +239,25 @@
            return;
        }
        String toEndingId = glassInfo.getTemperingLayoutId() + "" + glassInfo.getTemperingFeedSequence();
        List<ReadWriteEntity> list = new ArrayList<>();
//        list.add(generateReadWriteEntity("MB" + cell + ".MB" + cell + ".mesControl", true));
        list.add(generateReadWriteEntity("MB" + cell + ".MB" + cell + ".glassId", Integer.parseInt(toEndingId)));
        list.add(generateReadWriteEntity("MB" + cell + ".MB" + cell + ".toEdingId", Integer.parseInt(toEndingId)));
        list.add(generateReadWriteEntity("MB" + cell + ".MB" + cell + ".width", (int) Math.max(glassInfo.getWidth() * ratio, glassInfo.getHeight() * ratio)));
        list.add(generateReadWriteEntity("MB" + cell + ".MB" + cell + ".height", (int) Math.min(glassInfo.getWidth() * ratio, glassInfo.getHeight() * ratio)));

        miloService.writeToOpcUa(list);
        miloService.writeToOpcWord(generateReadWriteEntity("MB" + cell + ".MB" + cell + ".thickness", (int) glassInfo.getThickness() * ratio));
        S7DataMB s7DataMB = new S7DataMB();
        s7DataMB.setToEdingId(Integer.parseInt(toEndingId));
        s7DataMB.setGlassId(Integer.parseInt(toEndingId));
        s7DataMB.setWidth((int) Math.max(glassInfo.getWidth() * ratio, glassInfo.getHeight() * ratio));
        s7DataMB.setHeight((int) Math.min(glassInfo.getWidth() * ratio, glassInfo.getHeight() * ratio));
        log.info("玻璃id:{},{}线向PLC发送宽高数据{}", glassId, cell, s7DataMB);
        if (cell == 1) {
            s7SerializerMBOne.write(s7DataMB);
        } else {
            s7SerializerMBTwo.write(s7DataMB);
        }
        s7DataMB = new S7DataMB();
        s7DataMB.setThickness((int) (glassInfo.getThickness() * ratio));
        log.info("{}线向PLC发送厚度数据{}", cell, s7DataMB);
        if (cell == 1) {
            s7SerializerMBOne.write(s7DataMB);
        } else {
            s7SerializerMBTwo.write(s7DataMB);
        }
        //修改磨边对列中的磨边线路及状态
        edgGlassTaskInfoService.update(new LambdaUpdateWrapper<EdgGlassTaskInfo>()
                .set(EdgGlassTaskInfo::getLine, cell)
@@ -242,9 +272,9 @@
        }
    }

    private boolean intoTask(EdgStorageDeviceTask task, String tableName, int deviceId) {
    private boolean intoTask(S7DataWL task, int deviceId) {
        Date startDate = new Date();
        log.info("开始执行进片任务，任务信息为：{},表名为：{},设备id:{},开始时间：{}", task, tableName, deviceId, startDate);
        log.info("开始执行进片任务，任务信息为：{},设备id:{},开始时间：{}", task, deviceId, startDate);
        //获取玻璃的基本信息
        GlassInfo glassInfo = glassInfoService.getOne(new LambdaQueryWrapper<GlassInfo>().eq(GlassInfo::getGlassId, task.getGlassIdIn()));
        if (null == glassInfo) {
@@ -274,7 +304,7 @@
            log.info("结束进片任务设备为{}，结束时间为：{}，共耗时：{}ms", deviceId, endDate, endDate.getTime() - startDate.getTime());
            return Boolean.FALSE;
        }
        EdgStorageCage edgStorageCage = edgStorageCageService.selectNearestEmpty(task.getCurrentCell(), deviceId, Boolean.FALSE);
        EdgStorageCage edgStorageCage = edgStorageCageService.selectNearestEmpty(Integer.parseInt(task.getCurrentCell().toString()), deviceId, Boolean.FALSE);
        Assert.isTrue(null != edgStorageCage, "格子已满");
        log.info("4、将玻璃信息插入卧式理片笼,当前玻璃信息:{}", glassInfo);
        EdgStorageCageDetails details = new EdgStorageCageDetails();
@@ -287,7 +317,17 @@
        //更新任务信息
        task.setStartCell(edgStorageCage.getSlot());
        task.setTaskRunning(Const.GLASS_CACHE_TYPE_IN);
        edgStorageDeviceTaskService.updateTaskMessage(tableName, task);
        if (deviceId == 1) {
            s7SerializerWLOne.write(
                    S7DataWL.builder().startCell(edgStorageCage.getSlot())
                            .taskRunning(Const.GLASS_CACHE_TYPE_IN).build()
            );
        } else {
            s7SerializerWLTwo.write(
                    S7DataWL.builder().startCell(edgStorageCage.getSlot())
                            .taskRunning(Const.GLASS_CACHE_TYPE_IN).build()
            );
        }
        saveHistoryTask(task, deviceId);
        //记录进片任务的玻璃id用于下次任务的比较，防止同一块玻璃重复执行
        if (deviceId == 1) {
@@ -300,29 +340,20 @@
        return Boolean.TRUE;
    }

    private boolean outTask(EdgStorageDeviceTask task, String tableName, int deviceId, int cellFlag) throws Exception {
    private boolean outTask(S7DataWL task, int deviceId, int cellFlag) {
        Date startDate = new Date();
        //获取对应的设备状态信息
        ReadWriteEntity oneOutStateEntity = miloService.readFromOpcUa("WL1.WL1.slotState");
        ReadWriteEntity twoOutStateEntity = miloService.readFromOpcUa("WL2.WL2.slotState");
        ReadWriteEntity d06OutStateEntity = miloService.readFromOpcUa("WL2.WL2.d06SlotState");
        S7DataWL s7DataWLOne = s7SerializerWLOne.read(S7DataWL.class);
        S7DataWL s7DataWLTwo = s7SerializerWLTwo.read(S7DataWL.class);
        S7DataWLExtra s7DataWLExtraTwo = s7SerializerWLTwo.read(S7DataWLExtra.class);
        Integer oneOutState = s7DataWLOne.getSlotState();
        Integer twoOutState = s7DataWLTwo.getSlotState();
        Integer d06OutState = s7DataWLExtraTwo.getD06SlotState();
        //状态有3中情况：0空闲 1忙碌 2禁用
        String oneOutState = Const.OUT_DISABLE;
        String twoOutState = Const.OUT_DISABLE;
        String d06OutState = Const.OUT_DISABLE;
        if (null != oneOutStateEntity && null != oneOutStateEntity.getValue()) {
            oneOutState = oneOutStateEntity.getValue().toString();
        }
        if (null != twoOutStateEntity && null != twoOutStateEntity.getValue()) {
            twoOutState = twoOutStateEntity.getValue().toString();
        }
        //两条线都为禁用则不出玻璃
        if (Const.OUT_DISABLE.equals(oneOutState) && Const.OUT_DISABLE.equals(twoOutState)) {
            log.info("A09、A10为{},{}非自动状态，无法出片", oneOutState, oneOutState);
            return Boolean.FALSE;
        }
        if (null != d06OutStateEntity && null != d06OutStateEntity.getValue()) {
            d06OutState = d06OutStateEntity.getValue().toString();
        }
        //获取d06片台状态
        // 1:一对一的情况下不需要判断d06状态
@@ -330,18 +361,14 @@
        // 3:二号线一对多的情况下，获取一号线磨边前片台C08的状态，C08非禁用时，一号线将按照D06片台状态觉得出片
        if (cellFlag == 2) {
            if (deviceId == 1) {
                twoOutState = Const.OUT_DISABLE.equals(twoOutState) ? Const.OUT_DISABLE : d06OutState;
                twoOutState = twoOutState & d06OutState;
            } else {
                oneOutState = Const.OUT_DISABLE.equals(oneOutState) ? Const.OUT_DISABLE : d06OutState;
            }
            if (Const.OUT_BUSY.equals(oneOutState) && Const.OUT_BUSY.equals(twoOutState)) {
                log.info("A09、A10为{},{}非自动状态，无法出片", oneOutState, oneOutState);
                return Boolean.FALSE;
                oneOutState = oneOutState & d06OutState;
            }
        }

        log.info("开始执行出片/直通任务，任务信息为：{},表名为：{},设备id:{},开始时间：{},一号线状态：{}，二号线状态：{}",
                task, tableName, deviceId, startDate, oneOutState, twoOutState);
        log.info("开始执行出片/直通任务，任务信息为：{},设备id:{},开始时间：{},一号线状态：{}，二号线状态：{}",
                task, deviceId, startDate, oneOutState, twoOutState);
        //获取当前需要走那条线
        int cell = 0;
        if (cellFlag == 1) {
@@ -352,25 +379,21 @@
            } else if (Const.OUT_FREE.equals(oneOutState)) {
                cell = Const.ONE_OUT_TARGET_POSITION;
            } else {
                return Boolean.FALSE;
                cell = Const.TWO_OUT_TARGET_POSITION;
            }
        }
        if (Const.OUT_FREE.equals(oneOutState) && Const.OUT_FREE.equals(twoOutState)) {
            if (cellFlag == 2) {
                if (!outChildTask(task, tableName, deviceId, cell, startDate)) {
                    cell = cell == Const.ONE_OUT_TARGET_POSITION ? Const.TWO_OUT_TARGET_POSITION : Const.ONE_OUT_TARGET_POSITION;
                    return outChildTask(task, tableName, deviceId, cell, startDate);
                }
            } else {
                return outChildTask(task, tableName, deviceId, cell, startDate);
        if (cellFlag == 2) {
            if (!outChildTask(task, deviceId, cell, startDate)) {
                cell = cell == Const.ONE_OUT_TARGET_POSITION ? Const.TWO_OUT_TARGET_POSITION : Const.ONE_OUT_TARGET_POSITION;
                return outChildTask(task, deviceId, cell, startDate);
            }
        } else {
            return outChildTask(task, tableName, deviceId, cell, startDate);
            return outChildTask(task, deviceId, cell, startDate);
        }
        return Boolean.TRUE;
    }

    private boolean outChildTask(EdgStorageDeviceTask task, String tableName, int deviceId, int cell, Date startDate) {
    private boolean outChildTask(S7DataWL task, int deviceId, int cell, Date startDate) {
        EdgStorageCageDetails edgStorageCageDetails = null;

        //笼内是版图相差是否超过阈值
@@ -424,7 +447,7 @@
        }
        //前面已经尺寸问题处理完毕，开始计算无相同尺寸的新玻璃小片
        if (null == edgStorageCageDetails) {
            edgStorageCageDetails = edgStorageCageDetailsService.queryEdgStorageDetailsByLimitSize(deviceId, task.getCurrentCell(), 0, 0,
            edgStorageCageDetails = edgStorageCageDetailsService.queryEdgStorageDetailsByLimitSize(deviceId, Integer.parseInt(task.getCurrentCell().toString()), 0, 0,
                    cell, minOneFirstLength, minOneSecondLength, maxTwoFirstLength, maxTwoSecondLength, maxThickness);
        }
        if (edgStorageCageDetails == null && StringUtils.isNotBlank(task.getGlassIdIn())) {
@@ -508,8 +531,25 @@
        task.setStartCell(edgStorageCageDetails.getSlot());
        task.setTaskRunning(taskType);
        task.setEndCell(cell);

        edgStorageDeviceTaskService.updateTaskMessage(tableName, task);
        if (deviceId == 1) {
            s7SerializerWLOne.write(
                    S7DataWL.builder()
                            .glassIdOut(edgStorageCageDetails.getGlassId())
                            .startCell(edgStorageCageDetails.getSlot())
                            .taskRunning(taskType)
                            .endCell(cell)
                            .build()
            );
        } else {
            s7SerializerWLTwo.write(
                    S7DataWL.builder()
                            .glassIdOut(edgStorageCageDetails.getGlassId())
                            .startCell(edgStorageCageDetails.getSlot())
                            .taskRunning(taskType)
                            .endCell(cell)
                            .build()
            );
        }
        saveHistoryTask(task, deviceId);
        //记录直通任务的玻璃id用于下次任务的比较，防止同一块玻璃重复执行
        if (3 == task.getTaskState()) {
@@ -530,17 +570,13 @@
        return Boolean.TRUE;
    }

    private boolean finishTask(EdgStorageDeviceTask task, String tableName, int device) {
    private boolean finishTask(S7DataWL task, String tableName, int device) {
        if (task.getTaskState() <= 4) {
            log.info("有正在执行的任务或这任务已执行任务状态{}，任务启动情况{}，结束", task.getTaskState(), task.getTaskRunning());
            return Boolean.FALSE;
        }
        Date startDate = new Date();
        log.info("开始执行完成任务后清除动作，任务信息为：{},表名为：{},开始时间：{}", task, tableName, startDate);
        task.setTaskRunning(Const.GLASS_CACHE_TYPE_EMPTY);
        task.setGlassIdOut("");
        task.setStartCell(0);
        task.setEndCell(0);
        EdgStorageDeviceTaskHistory taskHistory = edgStorageDeviceTaskHistoryService.getOne(new LambdaQueryWrapper<EdgStorageDeviceTaskHistory>()
                .eq(EdgStorageDeviceTaskHistory::getTaskState, Const.RAW_GLASS_TASK_NEW)
                .eq(EdgStorageDeviceTaskHistory::getDeviceId, device)
@@ -558,13 +594,31 @@
            );
        }
        //最后更新任务，保证任务前的动作都做完
        edgStorageDeviceTaskService.updateTaskMessage(tableName, task);
        if (device == 1) {
            s7SerializerWLOne.write(
                    S7DataWL.builder()
                            .taskRunning(Const.GLASS_CACHE_TYPE_EMPTY)
                            .glassIdOut("")
                            .startCell(0)
                            .endCell(0)
                            .build()
            );
        } else {
            s7SerializerWLTwo.write(
                    S7DataWL.builder()
                            .taskRunning(Const.GLASS_CACHE_TYPE_EMPTY)
                            .glassIdOut("")
                            .startCell(0)
                            .endCell(0)
                            .build()
            );
        }
        Date endDate = new Date();
        log.info("结束完成任务后清除动作，表名为：{},结束时间为：{}，共耗时：{}ms", tableName, endDate, endDate.getTime() - startDate.getTime());
        return Boolean.TRUE;
    }

    private boolean damageTask(EdgStorageDeviceTask task, String tableName, int device) {
    private boolean damageTask(S7DataWL task, String tableName, int device) {
        if (task.getTaskState() <= 5) {
            log.info("任务未发生异常清空，任务结束，电气状态{},mes状态{}", task.getTaskState(), task.getTaskRunning());
            return Boolean.FALSE;
@@ -599,12 +653,25 @@
                    .set(EdgStorageDeviceTaskHistory::getTaskState, Const.RAW_GLASS_TASK_FAILURE)
            );
        }
        //最后更新任务，保证任务前的动作都做完
        task.setTaskRunning(Const.GLASS_CACHE_TYPE_EMPTY);
        task.setGlassIdOut("");
        task.setStartCell(0);
        task.setEndCell(0);
        edgStorageDeviceTaskService.updateTaskMessage(tableName, task);
        if (device == 1) {
            s7SerializerWLOne.write(
                    S7DataWL.builder()
                            .taskRunning(Const.GLASS_CACHE_TYPE_EMPTY)
                            .glassIdOut("")
                            .startCell(0)
                            .endCell(0)
                            .build()
            );
        } else {
            s7SerializerWLTwo.write(
                    S7DataWL.builder()
                            .taskRunning(Const.GLASS_CACHE_TYPE_EMPTY)
                            .glassIdOut("")
                            .startCell(0)
                            .endCell(0)
                            .build()
            );
        }
        Date endDate = new Date();
        log.info("完成执行异常处理任务后清除动作，表名为：{},结束时间为：{}，共耗时：{}ms", tableName, endDate, endDate.getTime() - startDate.getTime());
        return Boolean.TRUE;
@@ -619,7 +686,6 @@
     */
    public String queryAndChangeGlass(String glassId) {
        GlassInfo glassInfo = glassInfoService.getOne(new LambdaQueryWrapper<GlassInfo>().eq(GlassInfo::getGlassId, glassId));
//                .inSql(GlassInfo::getEngineerId, "select engineer_id from engineering where state = 1"));
        Assert.isFalse(null == glassInfo, "玻璃信息不存在");        //按照玻璃尺寸
        LambdaQueryWrapper<GlassInfo> queryWrapper = new LambdaQueryWrapper<GlassInfo>()
                .eq(GlassInfo::getWidth, glassInfo.getWidth())
@@ -744,9 +810,11 @@
        }
    }

    public boolean saveHistoryTask(EdgStorageDeviceTask task, int deviceId) {
    //    public boolean saveHistoryTask(EdgStorageDeviceTask task, int deviceId) {
    public boolean saveHistoryTask(S7DataWL task, int deviceId) {
        EdgStorageDeviceTaskHistory taskHistory = new EdgStorageDeviceTaskHistory();
        BeanUtils.copyProperties(task, taskHistory);
//        taskHistory.setTaskType(task.getTaskRunning());
        taskHistory.setTaskType(task.getTaskRunning());
        taskHistory.setCreateTime(new Date());
        taskHistory.setTaskState(Const.RAW_GLASS_TASK_NEW);

 hangzhoumesParent/moduleService/CacheGlassModule/src/main/java/com/mes/job/OpcCacheGlassTask.java

@@ -64,25 +64,21 @@
    @Resource
    DamageService damageService;

//    @Value("${mes.glassGap}")

    private int glassGap;
    //    @Value("${mes.threshold}")

    private int threshold;
    //    @Value("${mes.cellLength}")

    private int cellLength;
    //    @Value("${mes.ratio}")

    private int ratio;

    //    @Value("${mes.min.one.firstLength}")
    private int minOneFirstLength;

    //    @Value("${mes.min.one.secondLength}")
    private int minOneSecondLength;

    //    @Value("${mes.min.two.firstLength}")
    private int minTwoFirstLength;

    //    @Value("${mes.min.two.secondLength}")
    private int minTwoSecondLength;

    private String glassInIdOne = "";

 hangzhoumesParent/moduleService/CacheGlassModule/src/main/java/com/mes/job/OpcEdgTask.java

@@ -1,12 +1,15 @@
package com.mes.job;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.github.xingshuangs.iot.protocol.s7.serializer.S7Serializer;
import com.kangaroohy.milo.model.ReadWriteEntity;
import com.kangaroohy.milo.service.MiloService;
import com.mes.glassinfo.entity.GlassInfo;
import com.mes.glassinfo.service.GlassInfoService;
import com.mes.s7.entity.S7DataMBExtra;
import lombok.extern.slf4j.Slf4j;
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;
import org.springframework.util.StringUtils;
@@ -28,9 +31,12 @@
    @Autowired(required = false)
    MiloService miloService;

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

    @Resource
    GlassInfoService glassInfoService;


    @Scheduled(fixedDelay = 2000)
    public void startOneEdgTask() throws Exception {
@@ -43,27 +49,53 @@
    }

    private void startEdgTaskChild(String cell) throws Exception {
        ReadWriteEntity request = miloService.readFromOpcUa("MB04.MB04.request" + cell);
        if (null == request || "0".equals(request.getValue() + "")) {
        S7DataMBExtra s7DataMBExtra = s7SerializerMBExtra.read(S7DataMBExtra.class);
        log.info("MB04读取数据{}", s7DataMBExtra);
        String request = "";
        String glassIdEntity = "";
        if ("01".equals(cell)) {
            request = s7DataMBExtra.getRequestOne().toString();
            glassIdEntity = s7DataMBExtra.getPlcGlassIdOne();
        } else {
            request = s7DataMBExtra.getRequestTwo().toString();
            glassIdEntity = s7DataMBExtra.getPlcGlassIdTwo();
        }
        if (null == request || "0".equals(request)) {
            log.info("未收到玻璃请求，结束本次任务");
            return;
        }
        ReadWriteEntity glassIdEntity = miloService.readFromOpcUa("MB04.MB04.plc_glass_id_" + cell);

        if (null == glassIdEntity || StringUtils.isEmpty(glassIdEntity.getValue() + "")) {
        if (null == glassIdEntity || StringUtils.isEmpty(glassIdEntity)) {
            log.info("有请求但玻璃id为空，结束本次任务");
            return;
        }
        String glassId = glassIdEntity.getValue() + "";
        String glassId = glassIdEntity;
        log.info("获取到{}线的玻璃id:{}", cell, glassId);
        GlassInfo glassInfo = glassInfoService.getOne(new LambdaQueryWrapper<GlassInfo>().eq(GlassInfo::getGlassId, glassId).last("limit 1"));

        List<ReadWriteEntity> ualist = new ArrayList<>();
        ualist.add(generateReadWriteEntity("MB04.MB04.width" + cell, (int) Math.max(glassInfo.getWidth() * 10, glassInfo.getHeight() * 10)));
        ualist.add(generateReadWriteEntity("MB04.MB04.height" + cell, (int) Math.min(glassInfo.getWidth() * 10, glassInfo.getHeight() * 10)));
        ualist.add(generateReadWriteEntity("MB04.MB04.thickness" + cell, (int) glassInfo.getThickness() * 10));
        miloService.writeToOpcWord(ualist);
        miloService.writeToOpcUa(generateReadWriteEntity("MB04.MB04.mes_glass_Id_" + cell, glassId));
        log.info("{}线发送尺寸信息宽：{}，高：{}，厚度：{}", cell, Math.max(glassInfo.getWidth() * 10, glassInfo.getHeight() * 10), Math.min(glassInfo.getWidth() * 10, glassInfo.getHeight() * 10), glassInfo.getThickness() * 10);
        if ("01".equals(cell)) {
            s7SerializerMBExtra.write(
                    S7DataMBExtra.builder()
                            .widthOne((int) Math.max(glassInfo.getWidth() * 10, glassInfo.getHeight() * 10))
                            .heightOne((int) Math.min(glassInfo.getWidth() * 10, glassInfo.getHeight() * 10))
                            .thicknessOne((int) (glassInfo.getThickness() * 10))
                            .build()
            );
            s7SerializerMBExtra.write(
                    S7DataMBExtra.builder().mesGlassIdOne(glassId).build()
            );
        } else {
            s7SerializerMBExtra.write(
                    S7DataMBExtra.builder()
                            .widthTwo((int) Math.max(glassInfo.getWidth() * 10, glassInfo.getHeight() * 10))
                            .heightTwo((int) Math.min(glassInfo.getWidth() * 10, glassInfo.getHeight() * 10))
                            .thicknessTwo((int) (glassInfo.getThickness() * 10))
                            .build()
            );
            s7SerializerMBExtra.write(
                    S7DataMBExtra.builder().mesglassIdTwo(glassId).build()
            );
        }
    }

    private ReadWriteEntity generateReadWriteEntity(String identifier, Object value) {

 hangzhoumesParent/moduleService/CacheGlassModule/src/main/java/com/mes/s7/entity/S7DataMB.java

New file
@@ -0,0 +1,52 @@
package com.mes.s7.entity;

import com.github.xingshuangs.iot.common.enums.EDataType;
import com.github.xingshuangs.iot.protocol.s7.serializer.S7Variable;
import lombok.Data;

/**
 * @Author : zhoush
 * @Date: 2025/4/30 14:19
 * @Description:
 */
@Data
public class S7DataMB {


    @S7Variable(address = "DB323.6", type = EDataType.FLOAT32)
    private Float speed;

    @S7Variable(address = "DB324.2", type = EDataType.INT32)
    private Integer toEdingId;

    @S7Variable(address = "DB324.6", type = EDataType.INT32)
    private Integer glassId;

    @S7Variable(address = "DB324.10", type = EDataType.INT32)
    private Integer width;

    @S7Variable(address = "DB324.14", type = EDataType.INT32)
    private Integer height;

    @S7Variable(address = "DB324.18", type = EDataType.UINT16)
    private Integer thickness;

    @S7Variable(address = "DB324.0.3", type = EDataType.BOOL)
    private Boolean mesControl;

//    @S7Variable(address = "DB49.126", type = EDataType.INT32)
//    private Integer toEdingId;
//
//    @S7Variable(address = "DB49.130", type = EDataType.INT32)
//    private Integer glassId;
//
//    @S7Variable(address = "DB49.134", type = EDataType.INT32)
//    private Integer width;
//
//    @S7Variable(address = "DB49.138", type = EDataType.INT32)
//    private Integer height;
//
//    @S7Variable(address = "DB49.142", type = EDataType.UINT16)
//    private Short thickness;

}

 hangzhoumesParent/moduleService/CacheGlassModule/src/main/java/com/mes/s7/entity/S7DataMBExtra.java

New file
@@ -0,0 +1,58 @@
package com.mes.s7.entity;

import com.github.xingshuangs.iot.common.enums.EDataType;
import com.github.xingshuangs.iot.protocol.s7.serializer.S7Variable;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * @Author : zhoush
 * @Date: 2025/4/30 14:19
 * @Description:
 */
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class S7DataMBExtra {


    @S7Variable(address = "DB49.0", type = EDataType.UINT16)
    private Integer requestOne;

    @S7Variable(address = "DB49.46", type = EDataType.UINT16)
    private Integer widthOne;

    @S7Variable(address = "DB49.48", type = EDataType.UINT16)
    private Integer heightOne;

    @S7Variable(address = "DB49.50", type = EDataType.UINT16)
    private Integer thicknessOne;

    @S7Variable(address = "DB49.52", type = EDataType.UINT16)
    private Integer requestTwo;

    @S7Variable(address = "DB49.98", type = EDataType.UINT16)
    private Integer widthTwo;

    @S7Variable(address = "DB49.100", type = EDataType.UINT16)
    private Integer heightTwo;

    @S7Variable(address = "DB49.102", type = EDataType.UINT16)
    private Integer thicknessTwo;

    @S7Variable(address = "DB49.2", type = EDataType.STRING, count = 14)
    private String plcGlassIdOne;

    @S7Variable(address = "DB49.24", type = EDataType.STRING, count = 14)
    private String mesGlassIdOne;

    @S7Variable(address = "DB49.54", type = EDataType.STRING, count = 14)
    private String plcGlassIdTwo;

    @S7Variable(address = "DB49.76", type = EDataType.STRING, count = 14)
    private String mesglassIdTwo;

}

 hangzhoumesParent/moduleService/CacheGlassModule/src/main/java/com/mes/s7/entity/S7DataWL.java

New file
@@ -0,0 +1,58 @@
package com.mes.s7.entity;

import com.github.xingshuangs.iot.common.enums.EDataType;
import com.github.xingshuangs.iot.protocol.s7.serializer.S7Variable;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

/**
 * @Author : zhoush
 * @Date: 2025/4/30 14:19
 * @Description:
 */
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class S7DataWL {


    @S7Variable(address = "DB49.0", type = EDataType.UINT16)
    private Integer taskRunning;

    @S7Variable(address = "DB49.46", type = EDataType.UINT16)
    private Integer currentCell;

    @S7Variable(address = "DB49.48", type = EDataType.UINT16)
    private Integer startCell;

    @S7Variable(address = "DB49.50", type = EDataType.UINT16)
    private Integer endCell;

    @S7Variable(address = "DB49.52", type = EDataType.UINT16)
    private Integer TaskState;

    @S7Variable(address = "DB49.116", type = EDataType.UINT16)
    private Integer inPlace;

    @S7Variable(address = "DB49.124", type = EDataType.UINT16)
    private Integer slotState;

    @S7Variable(address = "DB49.118", type = EDataType.FLOAT32)
    private Float speed;

    @S7Variable(address = "DB49.2", type = EDataType.STRING, count = 14)
    private String glassIdIn;

    @S7Variable(address = "DB49.24", type = EDataType.STRING, count = 14)
    private String glassIdOut;

    @S7Variable(address = "DB49.94", type = EDataType.STRING, count = 14)
    private String glassId;

    @S7Variable(address = "DB49.112.0", type = EDataType.BOOL)
    private Boolean deviceState;

}

 hangzhoumesParent/moduleService/CacheGlassModule/src/main/java/com/mes/s7/entity/S7DataWLExtra.java

New file
@@ -0,0 +1,18 @@
package com.mes.s7.entity;

import com.github.xingshuangs.iot.common.enums.EDataType;
import com.github.xingshuangs.iot.protocol.s7.serializer.S7Variable;
import lombok.Data;

/**
 * @Author : zhoush
 * @Date: 2025/4/30 14:19
 * @Description:
 */
@Data
public class S7DataWLExtra {

    @S7Variable(address = "DB49.126", type = EDataType.UINT16)
    private Integer d06SlotState;

}

 hangzhoumesParent/moduleService/CacheGlassModule/src/main/resources/application-yw.yml

@@ -32,7 +32,7 @@
    password: 123456
kangaroohy:
  milo:
    enabled: true
    enabled: false
    primary: default
    config:
      default:

 hangzhoumesParent/moduleService/CacheGlassModule/src/main/resources/application.yml

@@ -3,7 +3,7 @@

spring:
  profiles:
    active: dev
    active: yw
  application:
    name: cacheGlass
  liquibase:

 hangzhoumesParent/moduleService/CacheVerticalGlassModule/src/main/java/com/mes/config/S7Config.java

New file
@@ -0,0 +1,30 @@
package com.mes.config;

import com.github.xingshuangs.iot.protocol.s7.enums.EPlcType;
import com.github.xingshuangs.iot.protocol.s7.serializer.S7Serializer;
import com.github.xingshuangs.iot.protocol.s7.service.S7PLC;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @Author : zhoush
 * @Date: 2025/4/30 13:50
 * @Description:
 */
@Configuration
public class S7Config {
    @Bean(name = "s7SerializerDLPOne")
    public S7Serializer s7SerializerDLPOne() {
        S7PLC s7PLC = new S7PLC(EPlcType.S1500, "192.168.20.140");
//        S7PLC s7PLC = new S7PLC(EPlcType.S1500, "10.153.19.191");
        return S7Serializer.newInstance(s7PLC);
    }

    @Bean(name = "s7SerializerDLPTwo")
    public S7Serializer s7SerializerDLPTwo() {
        S7PLC s7PLC = new S7PLC(EPlcType.S1500, "192.168.20.140");
//        S7PLC s7PLC = new S7PLC(EPlcType.S1500, "10.153.19.191");
        return S7Serializer.newInstance(s7PLC);
    }

}

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

@@ -2,6 +2,7 @@

import cn.hutool.json.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.github.xingshuangs.iot.protocol.s7.serializer.S7Serializer;
import com.kangaroohy.milo.model.ReadWriteEntity;
import com.kangaroohy.milo.service.MiloService;
import com.mes.bigstorage.entity.BigStorageCageDetails;
@@ -17,12 +18,16 @@
import com.mes.glassinfo.service.GlassInfoService;
import com.mes.largenscreen.entity.PieChartVO;
import com.mes.largenscreen.entity.RunTime;
import com.mes.s7.entity.S7DataDLPOne;
import com.mes.s7.entity.S7DataDLPTwo;
import com.mes.temperingglass.entity.TemperingGlassInfo;
import com.mes.temperingglass.service.TemperingGlassInfoService;
import com.mes.tools.WebSocketServer;
import com.mes.utils.RedisUtil;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang.StringUtils;
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;

@@ -58,9 +63,19 @@
    @Autowired(required = false)
    MiloService miloService;

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

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

    private JSONObject jsonObject = new JSONObject();

    public void queryDataSource1() throws Exception {
        S7DataDLPOne s7DataDLPOne = s7SerializerDLPOne.read(S7DataDLPOne.class);
        S7DataDLPTwo s7DataWLTwo = s7SerializerDLPTwo.read(S7DataDLPTwo.class);
        List<Double> carPostion = new ArrayList<>();
        carPostion.add(0.25);
        carPostion.add(0.5);
@@ -71,14 +86,17 @@
        try {
            //进片任务数据
            List<BigStorageTaskVO> inTaskList = new ArrayList();
            ReadWriteEntity fromOpcUa = miloService.readFromOpcUa("DLP1A.DLP1A.FROM1");
            String fromOpcUa = s7DataDLPOne.getFrom1().toString();
            List<Integer> states = s7DataDLPOne.getStates();
            List<Integer> tos = s7DataDLPOne.getTos();
            List<String> ids = s7DataDLPOne.getIds();
            for (int i = 1; i <= 6; i++) {
                ReadWriteEntity requestWord = miloService.readFromOpcUa("DLP1A.DLP1A.DI" + i);
                ReadWriteEntity targetSlotWord = miloService.readFromOpcUa("DLP1A.DLP1A.TO" + i);
                ReadWriteEntity stateWord = miloService.readFromOpcUa("DLP1A.DLP1A.STATE" + i);
                if (null != requestWord.getValue()) {
                String requestWord = ids.get(i - 1);
                String targetSlotWord = tos.get(i - 1).toString();
                String stateWord = states.get(i - 1).toString();
                if (StringUtils.isNotEmpty(requestWord)) {
                    BigStorageTaskVO task = new BigStorageTaskVO();
                    task.setGlassId(requestWord.getValue() + "");
                    task.setGlassId(requestWord);
                    int isExistCount = bigStorageCageDetailsService.count(new LambdaQueryWrapper<BigStorageCageDetails>().in(BigStorageCageDetails::getGlassId, task.getGlassId())
                            .in(BigStorageCageDetails::getState, Const.GLASS_STATE_IN_ALL));
                    if (isExistCount > 0) {
@@ -86,9 +104,9 @@
                    } else {
                        task.setIsSame(0);
                    }
                    task.setStartSlot(Integer.parseInt(fromOpcUa.getValue() + ""));
                    task.setTargetSlot(Integer.parseInt(targetSlotWord.getValue() + ""));
                    task.setTaskState(Integer.parseInt(stateWord.getValue() + ""));
                    task.setStartSlot(Integer.parseInt(fromOpcUa));
                    task.setTargetSlot(Integer.parseInt(targetSlotWord));
                    task.setTaskState(Integer.parseInt(stateWord));
                    inTaskList.add(task);
                    continue;
                }
@@ -99,24 +117,78 @@
        }
        try {
            //进片联机
            ReadWriteEntity inkageEntity = miloService.readFromOpcUa("DLP1A.DLP1A.mesControl");
            jsonObject.append("inkageEntity", inkageEntity.getValue());
            Boolean inkageEntity = s7DataDLPOne.getMesControl();
            jsonObject.append("inkageEntity", inkageEntity);
            //进片请求
            ReadWriteEntity requestEntity = miloService.readFromOpcUa("DLP1A.DLP1A.RequestMes");
            jsonObject.append("requestEntity", requestEntity.getValue());
            String requestEntity = s7DataDLPOne.getRequestMes().toString();
            jsonObject.append("requestEntity", requestEntity);
            //启动命令
            ReadWriteEntity mesReplyEntity = miloService.readFromOpcUa("DLP1A.DLP1A.MesReply");
            jsonObject.append("mesReplyEntity", mesReplyEntity.getValue());
            String mesReplyEntity = s7DataDLPOne.getMesReply().toString();
            jsonObject.append("mesReplyEntity", mesReplyEntity);
            //出片联机
            ReadWriteEntity outInkageEntity = miloService.readFromOpcUa("DLP1B.DLP1B.mesControl");
            jsonObject.append("outInkageEntity", outInkageEntity.getValue());
            Boolean outInkageEntity = s7DataWLTwo.getMesControl();
            jsonObject.append("outInkageEntity", outInkageEntity);
            //出片请求
            ReadWriteEntity outRequestEntity = miloService.readFromOpcUa("DLP1B.DLP1B.RequestMes");
            jsonObject.append("outRequestEntity", outRequestEntity.getValue());
            String outRequestEntity = s7DataWLTwo.getRequestMes().toString();
            jsonObject.append("outRequestEntity", outRequestEntity);


            //出片任务数据
            List<BigStorageCageTask> outTaskList = bigStorageCageTaskService.queryTaskMessage("big_storage_cage_out_one_task");
            List<BigStorageCageTask> outTaskList = new ArrayList<>();
            for (int i = 0; i < 6; i++) {

                BigStorageCageTask bigStorageCageTask = new BigStorageCageTask();
                String glassId = "";
                Integer startSlot = 0;
                Integer targetSlot = 0;
                Integer taskState = 0;
                switch (i) {
                    case 0:
                        glassId = s7DataWLTwo.getId1();
                        startSlot = s7DataWLTwo.getFrom1();
                        targetSlot = s7DataWLTwo.getTo1();
                        taskState = s7DataWLTwo.getState1();
                        ;
                        break;
                    case 1:
                        glassId = s7DataWLTwo.getId2();
                        startSlot = s7DataWLTwo.getFrom2();
                        targetSlot = s7DataWLTwo.getTo2();
                        taskState = s7DataWLTwo.getState2();
                        break;
                    case 2:
                        glassId = s7DataWLTwo.getId3();
                        startSlot = s7DataWLTwo.getFrom3();
                        targetSlot = s7DataWLTwo.getTo3();
                        taskState = s7DataWLTwo.getState3();
                        break;
                    case 3:
                        glassId = s7DataWLTwo.getId4();
                        startSlot = s7DataWLTwo.getFrom4();
                        targetSlot = s7DataWLTwo.getTo4();
                        taskState = s7DataWLTwo.getState4();
                        break;
                    case 4:
                        glassId = s7DataWLTwo.getId5();
                        startSlot = s7DataWLTwo.getFrom5();
                        targetSlot = s7DataWLTwo.getTo5();
                        taskState = s7DataWLTwo.getState5();
                        break;
                    case 5:
                        glassId = s7DataWLTwo.getId6();
                        startSlot = s7DataWLTwo.getFrom6();
                        targetSlot = s7DataWLTwo.getTo6();
                        taskState = s7DataWLTwo.getState6();
                        break;
                }
                if (StringUtils.isNotEmpty(glassId)) {
                    bigStorageCageTask.setGlassId(glassId);
                    bigStorageCageTask.setStartSlot(startSlot);
                    bigStorageCageTask.setTargetSlot(targetSlot);
                    bigStorageCageTask.setTaskState(taskState);
                    outTaskList.add(bigStorageCageTask);
                }
            }
            jsonObject.append("bigStorageCageDetailsOutTask", outTaskList);
        } catch (Exception e) {
            //todo:不做任务处理

 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;
@@ -31,6 +32,8 @@
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;
@@ -39,6 +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.Qualifier;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

@@ -76,6 +80,14 @@
    @Autowired(required = false)
    MiloService miloService;

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

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

    @Resource
    SysConfigService sysConfigService;

@@ -89,33 +101,37 @@

    @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);
        log.info("进片任务开始{}", s7DataDLPOne);
        Boolean inkageEntity = s7DataDLPOne.getMesControl();
        if (true != inkageEntity) {
            log.info("当前为非联机状态，结束进片任务");
            return;
        }
        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() + "")) {
        String mesReplyEntity = s7DataDLPOne.getMesReply().toString();
        if ("1".equals(mesReplyEntity)) {
            log.info("有正在执行的任务，结束进片任务");
            return;
        }
        //获取进片任务信息
        List<BigStorageCageTask> inTaskList = new ArrayList();
        ReadWriteEntity fromOpcUa = miloService.readFromOpcUa("DLP1A.DLP1A.FROM1");
        String fromOpcUa = s7DataDLPOne.getFrom1().toString();

        List<String> ids = s7DataDLPOne.getIds();
        List<String> glassIdList = new ArrayList<>();
        for (int i = 1; i <= 6; i++) {
            ReadWriteEntity requestWord = miloService.readFromOpcUa("DLP1A.DLP1A.DI" + i);
            if (null != requestWord.getValue()) {
        for (int i = 0; i < 6; i++) {
            String requestWord = ids.get(i);
            if (null != requestWord && !requestWord.isEmpty()) {
                BigStorageCageTask task = new BigStorageCageTask();
                task.setGlassId(requestWord.getValue() + "");
                task.setStartSlot(Integer.parseInt(fromOpcUa.getValue() + ""));
                task.setGlassId(requestWord);
                task.setStartSlot(Integer.parseInt(fromOpcUa));
                inTaskList.add(task);
                glassIdList.add(requestWord.getValue() + "");
                glassIdList.add(requestWord);
                continue;
            }
        }
@@ -124,11 +140,13 @@
            return;
        }
        log.info("获取任务的玻璃id：{}", glassIdList);
        ReadWriteEntity countEntity = miloService.readFromOpcUa("DLP1A.DLP1A.glassCount");
        if (null == countEntity.getValue() || Integer.parseInt(countEntity.getValue() + "") != glassIdList.size()) {
            log.info("当前大车进片玻璃数量{}与mes读取到的数量{}不匹配，结束进片任务", countEntity.getValue(), glassIdList.size());
        String countEntity = s7DataDLPOne.getGlassCount().toString();
        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.setAlarmSignal(1);
            s7SerializerDLPOne.write(s7DataDLPOne);
            return;
        }
        Map<String, Long> glassCountMap = glassIdList.stream().collect(Collectors.groupingBy(e -> e, Collectors.counting()));
@@ -136,7 +154,9 @@
            if (entry.getValue() > 1) {
                log.info("进片玻璃{}存在相同，结束本次任务", entry.getKey());
                //向plc发送报警:同一车进片玻璃存在相同
                miloService.writeToOpcWord(generateReadWriteEntity("DLP1A.DLP1A.alarmSignal", 2));
                s7DataDLPOne = new S7DataDLPOne();
                s7DataDLPOne.setAlarmSignal(2);
                s7SerializerDLPOne.write(s7DataDLPOne);
                return;
            }
        }
@@ -145,7 +165,9 @@
        if (CollectionUtil.isNotEmpty(detailsList)) {
            log.info("理片笼存在相同的进片玻璃{}，结束本次任务", detailsList);
            //向plc发送报警:理片笼存在相同的进片玻璃
            miloService.writeToOpcWord(generateReadWriteEntity("DLP1A.DLP1A.alarmSignal", 4));
            s7DataDLPOne = new S7DataDLPOne();
            s7DataDLPOne.setAlarmSignal(4);
            s7SerializerDLPOne.write(s7DataDLPOne);
            return;
        }
        List<GlassInfo> glassInfoList = glassInfoService.list(new LambdaQueryWrapper<GlassInfo>().in(GlassInfo::getGlassId, glassIdList));
@@ -153,7 +175,9 @@
        if (glassInfoList.size() != inTaskList.size()) {
            log.info("进片任务数量{}与玻璃数量{}不匹配，结束本次进片", inTaskList.size(), glassInfoList.size());
            //向plc发送报警:进片任务数量与系统查询到的玻璃数量不匹配
            miloService.writeToOpcWord(generateReadWriteEntity("DLP1A.DLP1A.alarmSignal", 8));
            s7DataDLPOne = new S7DataDLPOne();
            s7DataDLPOne.setAlarmSignal(8);
            s7SerializerDLPOne.write(s7DataDLPOne);
            return;
        }
        Integer glassGap = sysConfigService.queryConfigValue(ConstSysConfig.VERTICAL_GLASS_GAP);
@@ -171,7 +195,10 @@
                if (count < entry.getValue()) {
                    log.info("笼内格子剩余数量不足，结束本次进片");
                    //向plc发送报警:笼内格子剩余数量不足
                    miloService.writeToOpcWord(generateReadWriteEntity("DLP1A.DLP1A.alarmSignal", 16));
//                    miloService.writeToOpcWord(generateReadWriteEntity("DLP1A.DLP1A.alarmSignal", 16));
                    s7DataDLPOne = new S7DataDLPOne();
                    s7DataDLPOne.setAlarmSignal(16);
                    s7SerializerDLPOne.write(s7DataDLPOne);
                    return;
                }
            }
@@ -184,7 +211,10 @@
            if (count > 0) {
                log.info("直通片台存在玻璃，结束本次进片");
                //向plc发送报警:直通片台存在玻璃，无法继续直通
                miloService.writeToOpcWord(generateReadWriteEntity("DLP1A.DLP1A.alarmSignal", 64));
//                miloService.writeToOpcWord(generateReadWriteEntity("DLP1A.DLP1A.alarmSignal", 64));
                s7DataDLPOne = new S7DataDLPOne();
                s7DataDLPOne.setAlarmSignal(64);
                s7SerializerDLPOne.write(s7DataDLPOne);
                return;
            }
        }
@@ -206,14 +236,13 @@
                GlassInfo info = glassListMap.get(task.getGlassId()).get(0);
                BigStorageDTO bigStorageDTO = bigStorageGlassInfoService.queryBigStorageTargetSlot(info.getEngineerId(), info.getTemperingLayoutId(), info.getTemperingFeedSequence());
                //获取目标格子信息
//            BigStorageDTO bigStorageDTO = bigStorageCageDetailsService.queryTargetSlotByTempering(info);
//            临时更新格子的剩余尺寸：防止相邻玻璃进同一格子造成剩余尺寸不足，玻璃越界的情况，任务完成后再次更新大理片笼表剩余宽度（按照笼内玻璃数量更新大理片笼剩余尺寸）
                bigStorageCageService.update(new LambdaUpdateWrapper<BigStorageCage>()
                        .set(BigStorageCage::getRemainWidth, bigStorageDTO.getWidth() - Math.max(info.getWidth(), info.getHeight()) - glassGap)
                        .eq(BigStorageCage::getSlot, bigStorageDTO.getSlot()));
                task.setTargetSlot(bigStorageDTO.getSlot());
                task.setGlassId(info.getGlassId());
                bigStorageCageTaskService.updateTaskMessage("big_storage_cage_in_one_task", task);
//                bigStorageCageTaskService.updateTaskMessage("big_storage_cage_in_one_task", task);
                //存放历史任务
                BigStorageCageHistoryTask historyTask = new BigStorageCageHistoryTask();
                BeanUtils.copyProperties(task, historyTask);
@@ -236,7 +265,6 @@
        } else {
            BigStorageCageTask task = inTaskList.get(0);
            task.setTargetSlot(THROUGH_SLOT);
            bigStorageCageTaskService.updateTaskMessage("big_storage_cage_in_one_task", task);
            //存放历史任务
            BigStorageCageHistoryTask historyTask = new BigStorageCageHistoryTask();
            BeanUtils.copyProperties(task, historyTask);
@@ -260,29 +288,53 @@
        //历史数据入库
        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()));
        s7DataDLPOne = new S7DataDLPOne();
        for (int i = 0; i < inTaskList.size(); i++) {
            Integer value = 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);
        s7DataDLPOne = new S7DataDLPOne();
        s7DataDLPOne.setMesReply(1);
        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);
        log.info("出片任务开始{}", s7DataWLTwo);
        Boolean inkageEntity = s7DataWLTwo.getMesControl();
        if (true != inkageEntity) {
            log.info("当前为非联机状态，结束进片任务");
            return;
        }
        ReadWriteEntity requestEntity = miloService.readFromOpcUa("DLP1B.DLP1B.RequestMes");
        if (!"1".equals(requestEntity.getValue() + "")) {
        String requestEntity = s7DataWLTwo.getRequestMes().toString();
        if (!"1".equals(requestEntity)) {
            log.info("当前未收到出片请求，结束出片任务");
            return;
        }
        //获取出片任务表
        List<BigStorageCageTask> outTaskList = bigStorageCageTaskService.queryTaskMessage("big_storage_cage_out_one_task");
        List<BigStorageCageTask> outTaskList = getOutTaskList(s7DataWLTwo);
        if (CollectionUtil.isNotEmpty(outTaskList)) {
            log.info("有正在执行的出片任务，结束本次出片任务");
            return;
@@ -397,35 +449,73 @@

    @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);
        Boolean inkageEntity = s7DataDLPOne.getMesControl();
        if (true != inkageEntity) {
            log.info("当前为非联机状态，结束完成进片任务");
            return;
        }
        //获取进片任务表
//        List<BigStorageCageTask> inTaskList = bigStorageCageTaskService.queryTaskMessage("big_storage_cage_in_one_task");
        List<BigStorageCageTask> inTaskList = new ArrayList();

        List<String> glassIdList = new ArrayList<>();
        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);
        for (int i = 0; i < 6; i++) {
            String requestWord = "";
            String statetWord = "";
            String toOpcUa = "";
            String fromOpcUa = "";
            switch (i) {
                case 0:
                    requestWord = s7DataDLPOne.getId1();
                    statetWord = s7DataDLPOne.getState1().toString();
                    toOpcUa = s7DataDLPOne.getTo1().toString();
                    fromOpcUa = s7DataDLPOne.getFrom1().toString();
                    break;
                case 1:
                    requestWord = s7DataDLPOne.getId2();
                    statetWord = s7DataDLPOne.getState2().toString();
                    toOpcUa = s7DataDLPOne.getTo2().toString();
                    fromOpcUa = s7DataDLPOne.getFrom2().toString();
                    break;
                case 2:
                    requestWord = s7DataDLPOne.getId3();
                    statetWord = s7DataDLPOne.getState3().toString();
                    toOpcUa = s7DataDLPOne.getTo3().toString();
                    fromOpcUa = s7DataDLPOne.getFrom3().toString();
                    break;
                case 3:
                    requestWord = s7DataDLPOne.getId4();
                    statetWord = s7DataDLPOne.getState4().toString();
                    toOpcUa = s7DataDLPOne.getTo4().toString();
                    fromOpcUa = s7DataDLPOne.getFrom4().toString();
                    break;
                case 4:
                    requestWord = s7DataDLPOne.getId5();
                    statetWord = s7DataDLPOne.getState5().toString();
                    toOpcUa = s7DataDLPOne.getTo5().toString();
                    fromOpcUa = s7DataDLPOne.getFrom5().toString();
                    break;
                case 5:
                    requestWord = s7DataDLPOne.getId6();
                    statetWord = s7DataDLPOne.getState6().toString();
                    toOpcUa = s7DataDLPOne.getTo6().toString();
                    fromOpcUa = s7DataDLPOne.getFrom6().toString();
                    break;
            }

            if (null != requestWord.getValue()) {
            if (!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;
            }
        }
@@ -471,28 +561,30 @@
                    .eq(BigStorageCageHistoryTask::getGlassId, item.getGlassId()));
            item.setTargetSlot(0);
            //清空任务表数据
            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("DLP1A.DLP1A.TO" + i, 0));
        }
        list.add(generateReadWriteEntity("DLP1A.DLP1A.MesReply", 0));
        miloService.writeToOpcWord(list);
        s7DataDLPOne = new S7DataDLPOne();
        s7DataDLPOne.setTo1(0);
        s7DataDLPOne.setTo2(0);
        s7DataDLPOne.setTo3(0);
        s7DataDLPOne.setTo4(0);
        s7DataDLPOne.setTo5(0);
        s7DataDLPOne.setTo6(0);
        s7DataDLPOne.setMesReply(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);
        Boolean inkageEntity = s7DataWLTwo.getMesControl();
        if (true != inkageEntity) {
            log.info("当前为非联机状态，结束完成出片任务");
            return;
        }
        //获取进片任务表
        List<BigStorageCageTask> outTaskList = bigStorageCageTaskService.queryTaskMessage("big_storage_cage_out_one_task");
        //获取出片任务表
        List<BigStorageCageTask> outTaskList = getOutTaskList(s7DataWLTwo);
        if (CollectionUtil.isEmpty(outTaskList)) {
            log.info("当前大车无出片玻璃，结束完成出片任务");
            return;
@@ -576,10 +668,12 @@
            }
        }
//       重置任务表数据
        bigStorageCageTaskService.updateOutTaskMessage("big_storage_cage_out_one_task");
        resetOutTask();
        //清空启动状态
        //向opc发送启动信号
        miloService.writeToOpcWord(generateReadWriteEntity("DLP1B.DLP1B.MesReply", 0));
        S7DataDLPTwo s7DataDLPTwo = new S7DataDLPTwo();
        s7DataDLPTwo.setMesReply(0);
        s7SerializerDLPTwo.write(s7DataDLPTwo);
    }

    private void dealDamageInTask(List<BigStorageCageTask> damageTaskList) {
@@ -712,12 +806,52 @@
        List<String> glassIds = bigStorageCageTaskList.stream().map(BigStorageCageTask::getGlassId).collect(Collectors.toList());
        int glassCount = bigStorageCageTaskList.size();
        //生成出片任务条数不足6补全
        while (bigStorageCageTaskList.size() < 6) {
            bigStorageCageTaskList.add(new BigStorageCageTask("", 0, 0, 0));
        }
//        while (bigStorageCageTaskList.size() < 6) {
//            bigStorageCageTaskList.add(new BigStorageCageTask("", 0, 0, 0));
//        }
        //清空任务表数据
        bigStorageCageTaskService.removeAll("big_storage_cage_out_one_task");
        bigStorageCageTaskService.saveTaskMessage(tableName, bigStorageCageTaskList);
        resetOutTask();
        S7DataDLPTwo s7DataDLPTwo = new S7DataDLPTwo();
        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:
                        s7DataDLPTwo.setId1(glassId);
                        s7DataDLPTwo.setFrom1(startSlot);
                        s7DataDLPTwo.setTo1(target);
                        break;
                    case 1:
                        s7DataDLPTwo.setId2(glassId);
                        s7DataDLPTwo.setFrom2(startSlot);
                        s7DataDLPTwo.setTo2(target);
                        break;
                    case 2:
                        s7DataDLPTwo.setId3(glassId);
                        s7DataDLPTwo.setFrom3(startSlot);
                        s7DataDLPTwo.setTo3(target);
                        break;
                    case 3:
                        s7DataDLPTwo.setId4(glassId);
                        s7DataDLPTwo.setFrom4(startSlot);
                        s7DataDLPTwo.setTo4(target);
                        break;
                    case 4:
                        s7DataDLPTwo.setId5(glassId);
                        s7DataDLPTwo.setFrom5(startSlot);
                        s7DataDLPTwo.setTo5(target);
                        break;
                    case 5:
                        s7DataDLPTwo.setId6(glassId);
                        s7DataDLPTwo.setFrom6(startSlot);
                        s7DataDLPTwo.setTo6(target);
                        break;
                }
            }
        }
        s7SerializerDLPTwo.write(s7DataDLPTwo);
        List<BigStorageCageHistoryTask> historyList = bigStorageCageTaskList.stream().filter(e -> StringUtils.isNotBlank(e.getGlassId())).map(e -> {
            BigStorageCageHistoryTask history = new BigStorageCageHistoryTask();
            BeanUtils.copyProperties(e, history);
@@ -734,7 +868,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 = new S7DataDLPTwo();
            s7DataDLPTwo.setMesReply(1);
            s7SerializerDLPTwo.write(s7DataDLPTwo);
        } catch (Exception e) {
            e.printStackTrace();
        }
@@ -791,7 +928,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(1);
            s7SerializerDLPTwo.write(s7DataDLPTwo);
        } catch (Exception e) {
            e.printStackTrace();
        }
@@ -833,4 +973,54 @@
                .value(value)
                .build();
    }

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

    //读取出片地址
    private List<BigStorageCageTask> getOutTaskList(S7DataDLPTwo s7DataDLPTwo) {
        List<BigStorageCageTask> outTaskList = new ArrayList<>();
        List<String> glassIds = s7DataDLPTwo.getIds();
        List<Integer> startSlots = s7DataDLPTwo.getFroms();
        List<Integer> endSlots = s7DataDLPTwo.getTos();
        List<Integer> states = s7DataDLPTwo.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;
    }
}

 hangzhoumesParent/moduleService/CacheVerticalGlassModule/src/main/java/com/mes/s7/entity/S7DataDLPOne.java

New file
@@ -0,0 +1,118 @@
package com.mes.s7.entity;

import com.github.xingshuangs.iot.common.enums.EDataType;
import com.github.xingshuangs.iot.protocol.s7.serializer.S7Variable;
import lombok.Data;

import java.util.Arrays;
import java.util.List;

/**
 * @Author : zhoush
 * @Date: 2025/4/30 14:19
 * @Description:
 */
@Data
public class S7DataDLPOne {


    @S7Variable(address = "DB3.3118.0", type = EDataType.BOOL)
    private Boolean mesControl;

    @S7Variable(address = "DB7.0", type = EDataType.UINT16)
    private Integer requestMes;

    @S7Variable(address = "DB7.2", type = EDataType.UINT16)
    private Integer mesReply;

    @S7Variable(address = "DB7.140", type = EDataType.UINT16)
    private Integer from1;

    @S7Variable(address = "DB7.142", type = EDataType.UINT16)
    private Integer from2;

    @S7Variable(address = "DB7.144", type = EDataType.UINT16)
    private Integer from3;

    @S7Variable(address = "DB7.146", type = EDataType.UINT16)
    private Integer from4;

    @S7Variable(address = "DB7.148", type = EDataType.UINT16)
    private Integer from5;

    @S7Variable(address = "DB7.150", type = EDataType.UINT16)
    private Integer from6;

    @S7Variable(address = "DB7.152", type = EDataType.UINT16)
    private Integer to1;

    @S7Variable(address = "DB7.154", type = EDataType.UINT16)
    private Integer to2;

    @S7Variable(address = "DB7.156", type = EDataType.UINT16)
    private Integer to3;

    @S7Variable(address = "DB7.158", type = EDataType.UINT16)
    private Integer to4;

    @S7Variable(address = "DB7.160", type = EDataType.UINT16)
    private Integer to5;

    @S7Variable(address = "DB7.162", type = EDataType.UINT16)
    private Integer to6;

    @S7Variable(address = "DB7.164", type = EDataType.UINT16)
    private Integer state1;

    @S7Variable(address = "DB7.166", type = EDataType.UINT16)
    private Integer state2;

    @S7Variable(address = "DB7.168", type = EDataType.UINT16)
    private Integer state3;

    @S7Variable(address = "DB7.170", type = EDataType.UINT16)
    private Integer state4;

    @S7Variable(address = "DB7.172", type = EDataType.UINT16)
    private Integer state5;

    @S7Variable(address = "DB7.174", type = EDataType.UINT16)
    private Integer state6;

    @S7Variable(address = "DB7.1246", type = EDataType.UINT16)
    private Integer glassCount;

    @S7Variable(address = "DB7.8", type = EDataType.STRING, count = 14)
    private String id1;

    @S7Variable(address = "DB7.30", type = EDataType.STRING, count = 14)
    private String id2;

    @S7Variable(address = "DB7.52", type = EDataType.STRING, count = 14)
    private String id3;

    @S7Variable(address = "DB7.74", type = EDataType.STRING, count = 14)
    private String id4;

    @S7Variable(address = "DB7.96", type = EDataType.STRING, count = 14)
    private String id5;

    @S7Variable(address = "DB7.118", type = EDataType.STRING, count = 14)
    private String id6;

    @S7Variable(address = "MW1002", type = EDataType.UINT16)
    private Integer alarmSignal;

    public List<Integer> getStates() {
        return Arrays.asList(state1, state2, state3, state4, state5, state6);
    }

    public List<String> getIds() {
        return Arrays.asList(id1, id2, id3, id4, id5, id6);
    }

    public List<Integer> getTos() {
        return Arrays.asList(to1, to2, to3, to4, to5, to6);
    }

}

 hangzhoumesParent/moduleService/CacheVerticalGlassModule/src/main/java/com/mes/s7/entity/S7DataDLPTwo.java

New file
@@ -0,0 +1,117 @@
package com.mes.s7.entity;

import com.github.xingshuangs.iot.common.enums.EDataType;
import com.github.xingshuangs.iot.protocol.s7.serializer.S7Variable;
import io.swagger.models.auth.In;
import lombok.Data;

import java.util.Arrays;
import java.util.List;

/**
 * @Author : zhoush
 * @Date: 2025/4/30 14:19
 * @Description:
 */
@Data
public class S7DataDLPTwo {


    @S7Variable(address = "DB3.3118.0", type = EDataType.BOOL)
    private Boolean mesControl;

    @S7Variable(address = "DB7.4", type = EDataType.UINT16)
    private Integer requestMes;

    @S7Variable(address = "DB7.6", type = EDataType.UINT16)
    private Integer mesReply;

    @S7Variable(address = "DB7.308", type = EDataType.UINT16)
    private Integer from1;

    @S7Variable(address = "DB7.310", type = EDataType.UINT16)
    private Integer from2;

    @S7Variable(address = "DB7.312", type = EDataType.UINT16)
    private Integer from3;

    @S7Variable(address = "DB7.314", type = EDataType.UINT16)
    private Integer from4;

    @S7Variable(address = "DB7.316", type = EDataType.UINT16)
    private Integer from5;

    @S7Variable(address = "DB7.318", type = EDataType.UINT16)
    private Integer from6;

    @S7Variable(address = "DB7.320", type = EDataType.UINT16)
    private Integer to1;

    @S7Variable(address = "DB7.322", type = EDataType.UINT16)
    private Integer to2;

    @S7Variable(address = "DB7.324", type = EDataType.UINT16)
    private Integer to3;

    @S7Variable(address = "DB7.326", type = EDataType.UINT16)
    private Integer to4;

    @S7Variable(address = "DB7.328", type = EDataType.UINT16)
    private Integer to5;

    @S7Variable(address = "DB7.330", type = EDataType.UINT16)
    private Integer to6;

    @S7Variable(address = "DB7.332", type = EDataType.UINT16)
    private Integer state1;

    @S7Variable(address = "DB7.334", type = EDataType.UINT16)
    private Integer state2;

    @S7Variable(address = "DB7.336", type = EDataType.UINT16)
    private Integer state3;

    @S7Variable(address = "DB7.338", type = EDataType.UINT16)
    private Integer state4;

    @S7Variable(address = "DB7.340", type = EDataType.UINT16)
    private Integer state5;

    @S7Variable(address = "DB7.342", type = EDataType.UINT16)
    private Integer state6;

    @S7Variable(address = "DB7.176", type = EDataType.STRING, count = 14)
    private String id1;

    @S7Variable(address = "DB7.198", type = EDataType.STRING, count = 14)
    private String id2;

    @S7Variable(address = "DB7.220", type = EDataType.STRING, count = 14)
    private String id3;

    @S7Variable(address = "DB7.242", type = EDataType.STRING, count = 14)
    private String id4;

    @S7Variable(address = "DB7.264", type = EDataType.STRING, count = 14)
    private String id5;

    @S7Variable(address = "DB7.286", type = EDataType.STRING, count = 14)
    private String id6;

    public List<Integer> getStates() {
        return Arrays.asList(state1, state2, state3, state4, state5, state6);
    }

    public List<String> getIds() {
        return Arrays.asList(id1, id2, id3, id4, id5, id6);
    }

    public List<Integer> getTos() {
        return Arrays.asList(to1, to2, to3, to4, to5, to6);
    }

    public List<Integer> getFroms() {
        return Arrays.asList(from1, from2, from3, from4, from5, from6);
    }

}

 hangzhoumesParent/moduleService/CacheVerticalGlassModule/src/main/resources/application-yw.yml

@@ -30,7 +30,7 @@
    password: 123456
kangaroohy:
  milo:
    enabled: true
    enabled: false
    primary: default
    config:
      default:

 hangzhoumesParent/moduleService/CacheVerticalGlassModule/src/main/resources/application.yml

@@ -3,7 +3,7 @@

spring:
  profiles:
    active: dev
    active: yw
  application:
    name: cacheVerticalGlass
  liquibase:
@@ -15,8 +15,8 @@
      thread-name-prefix: task-cacheVertical
mybatis-plus:
  mapper-locations: classpath*:mapper/*.xml
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
#  configuration:
#    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
mes:
  sequence:
    order: true

 hangzhoumesParent/moduleService/GlassStorageModule/src/main/java/com/mes/config/S7Config.java

New file
@@ -0,0 +1,37 @@
package com.mes.config;

import com.github.xingshuangs.iot.protocol.s7.enums.EPlcType;
import com.github.xingshuangs.iot.protocol.s7.serializer.S7Serializer;
import com.github.xingshuangs.iot.protocol.s7.service.S7PLC;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @Author : zhoush
 * @Date: 2025/4/30 13:50
 * @Description:
 */
@Configuration
public class S7Config {

    @Bean(name = "s7SerializerCC")
    public S7Serializer s7SerializerCC() {
        S7PLC s7PLC = new S7PLC(EPlcType.S1200, "192.168.10.80");
//        S7PLC s7PLC = new S7PLC(EPlcType.S1500, "10.153.19.191");
        return S7Serializer.newInstance(s7PLC);
    }

    @Bean(name = "s7SerializerSPOne")
    public S7Serializer s7SerializerSPOne() {
        S7PLC s7PLC = new S7PLC(EPlcType.S1200, "192.168.10.15");
//        S7PLC s7PLC = new S7PLC(EPlcType.S1500, "10.153.19.191");
        return S7Serializer.newInstance(s7PLC);
    }

    @Bean(name = "s7SerializerSPTwo")
    public S7Serializer s7SerializerSPTwo() {
        S7PLC s7PLC = new S7PLC(EPlcType.S1200, "192.168.10.21");
//        S7PLC s7PLC = new S7PLC(EPlcType.S1500, "10.153.19.191");
        return S7Serializer.newInstance(s7PLC);
    }
}

 hangzhoumesParent/moduleService/GlassStorageModule/src/main/java/com/mes/job/RawGlassTask.java

@@ -17,11 +17,14 @@
import com.mes.rawglassstation.service.RawGlassStorageStationService;
import com.mes.rawglasstask.entity.RawGlassStorageTask;
import com.mes.rawglasstask.service.RawGlassStorageTaskService;
import com.mes.s7.entity.S7DataCC;
import com.mes.s7.entity.S7DataSP;
import com.mes.uppattenusage.entity.UpPattenUsage;
import com.mes.uppattenusage.entity.vo.UpPattenUsageVO;
import com.mes.uppattenusage.mapper.UpPattenUsageMapper;
import lombok.extern.slf4j.Slf4j;
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;
import org.springframework.util.CollectionUtils;
@@ -58,8 +61,17 @@
    @Autowired(required = false)
    private MiloService miloService;

    @Autowired(required = false)
    S7Serializer s7Serializer;
    @Autowired
    @Qualifier("s7SerializerCC")
    S7Serializer s7SerializerCC;

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

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


    private static final String LOAD_GLASS_DEVICE_ONE_TASK = "load_glass_device_one_task";
@@ -76,39 +88,25 @@

    @Scheduled(fixedDelay = 1000)
    public void rawStorageTask() throws Exception {
//        S7Data S7DataWL1 = s7Serializer.read(S7Data.class);
//        String requestWord = S7DataWL1.getRequest().toString();
//        String confireWord = S7DataWL1.getConfirmation().toString();
//        String reportWord = S7DataWL1.getReportWord().toString();
//        String taskWord = S7DataWL1.getTaskWord().toString();
//        String requestValue = requestWord;
        ReadWriteEntity requestWord = miloService.readFromOpcUa("CC.CC.request");
        ReadWriteEntity confireWord = miloService.readFromOpcUa("CC.CC.confirmation");
        ReadWriteEntity reportWord = miloService.readFromOpcUa("CC.CC.reportWord");
        ReadWriteEntity taskWord = miloService.readFromOpcUa("CC.CC.taskWord");
        String requestValue = requestWord.getValue() + "";
        S7DataCC S7DataCCOne = s7SerializerCC.read(S7DataCC.class);
        log.info("仓储通讯读取{}", S7DataCCOne);
        String requestWord = S7DataCCOne.getRequest().toString();
        String confireWord = S7DataCCOne.getConfirmation().toString();
        String reportWord = S7DataCCOne.getReportWord().toString();
        String taskWord = S7DataCCOne.getTaskWord().toString();
        String requestValue = requestWord;
        if ("0".equals(requestValue)) {
            if ("1".equals(confireWord) && "0".equals(reportWord)) {
//            if ("1".equals(confireWord.getValue() + "") && "0".equals(reportWord.getValue() + "")) {
//                S7Data s7Data = new S7Data();
//                s7Data.setConfirmation((short) 0);
//                s7Serializer.write(s7Data);
                List<ReadWriteEntity> list = new ArrayList<>();
                list.add(generateReadWriteEntity("CC.CC.confirmation", 0));
                miloService.writeToOpcWord(list);
                S7DataCC s7Data = new S7DataCC();
                s7Data.setConfirmation(0);
                s7SerializerCC.write(s7Data);
            }
//            if ("1".equals(taskWord)) {
          if ("1".equals(taskWord.getValue() + "")) {
//                S7Data s7Data = new S7Data();
//                s7Data.setTaskWord((short) 0);
//                s7Data.setStartSlot((short) 0);
//                s7Data.setEndSlot((short) 0);
//                s7Serializer.write(s7Data);
                List<ReadWriteEntity> list = new ArrayList<>();
                list.add(generateReadWriteEntity("CC.CC.taskWord", 0));
                list.add(generateReadWriteEntity("CC.CC.startSlot", 0));
                list.add(generateReadWriteEntity("CC.CC.endSlot", 0));
                miloService.writeToOpcWord(list);
            if ("1".equals(taskWord)) {
                S7DataCC s7Data = new S7DataCC();
                s7Data.setTaskWord(0);
                s7Data.setStartSlot(0);
                s7Data.setEndSlot(0);
                s7SerializerCC.write(s7Data);
            }
            return;
        }
@@ -148,10 +146,8 @@

    @Scheduled(fixedDelay = 1000)
    public void rawStorageInCar() throws Exception {
//        S7Data S7DataWL1 = s7Serializer.read(S7Data.class);
//        String value = S7DataWL1.getInCar().toString();
        ReadWriteEntity entity = miloService.readFromOpcUa("CC.CC.inCar");
        String value = entity.getValue() + "";
        S7DataCC S7DataCCOne = s7SerializerCC.read(S7DataCC.class);
        String value = S7DataCCOne.getInCar().toString();
        if (!"1".equals(value)) {
            log.info("大车上没有架子");
            return;
@@ -169,10 +165,8 @@

    @Scheduled(fixedDelay = 1000)
    public void rawStorageFinish() throws Exception {
//        S7Data S7DataWL1 = s7Serializer.read(S7Data.class);
//        String value = S7DataWL1.getReportWord().toString();
        ReadWriteEntity entity = miloService.readFromOpcUa("CC.CC.reportWord");
        String value = entity.getValue() + "";
        S7DataCC S7DataCCOne = s7SerializerCC.read(S7DataCC.class);
        String value = S7DataCCOne.getReportWord().toString();
        if ("0".equals(value)) {
            log.info("当前任务未汇报，结束本次任务");
            return;
@@ -235,12 +229,9 @@
                    .set(RawGlassStorageTask::getTaskState, Const.RAW_GLASS_TASK_FAILURE));

        }
//        S7Data s7Data = new S7Data();
//        s7Data.setConfirmation((short) 1);
//        s7Serializer.write(s7Data);
        List<ReadWriteEntity> list = new ArrayList<>();
        list.add(generateReadWriteEntity("CC.CC.confirmation", 1));
        miloService.writeToOpcWord(list);
        S7DataCC s7Data = new S7DataCC();
        s7Data.setConfirmation(1);
        s7SerializerCC.write(s7Data);
    }

    private boolean isHasRunningTask() {
@@ -297,13 +288,6 @@
        //生成出库任务
        rawGlassStorageDetailsService.generateTask(startSlot, lefting, startSlot, rawGlassList.get(0).getRemainQuantity(), Const.RAW_GLASS_TASK_TYPE_OUT);

//        List<ReadWriteEntity> list = new ArrayList<>();
//        list.add(generateReadWriteEntity("CC.CC.taskWord", 1));
//        list.add(generateReadWriteEntity("CC.CC.taskSending", 1));
//        list.add(generateReadWriteEntity("CC.CC.startSlot", startSlot));
//        list.add(generateReadWriteEntity("CC.CC.endSlot", lefting));
//        miloService.writeToOpcWord(list);

        //修改出片任务状态
        rawGlassStorageDetailsService.update(new LambdaUpdateWrapper<RawGlassStorageDetails>()
                .eq(RawGlassStorageDetails::getSlot, rawGlassList.get(0).getSlot())
@@ -325,15 +309,6 @@
            return Boolean.FALSE;
        }
        //生成复位任务

//        rawGlassStorageDetailsService.generatask(rawGlassList.get(0).getSlot(), rawGlassList.get(0).getShelf(), rawGlassList.get(0).getShelf(), rawGlassList.get(0).getRemainQuantity(), Const.RAW_GLASS_TASK_TYPE_DISPATCH);

//        List<ReadWriteEntity> list = new ArrayList<>();
//        list.add(generateReadWriteEntity("CC.CC.taskWord", 1));
//        list.add(generateReadWriteEntity("CC.CC.taskSending", 1));
//        list.add(generateReadWriteEntity("CC.CC.startSlot", startSlot));
//        list.add(generateReadWriteEntity("CC.CC.endSlot", lefting));
//        miloService.writeToOpcWord(list);

        //修改复位任务状态
        rawGlassStorageDetailsService.update(new LambdaUpdateWrapper<RawGlassStorageDetails>()
@@ -362,12 +337,6 @@
        RawGlassStorageDetails details = rawGlassList.get(0);
        rawGlassStorageDetailsService.generateTask(details.getSlot(), details.getShelf(), details.getShelf(),
                details.getRemainQuantity(), Const.RAW_GLASS_TASK_TYPE_IN);
//        List<ReadWriteEntity> list = new ArrayList<>();
//        list.add(generateReadWriteEntity("CC.CC.taskWord", 1));
//        list.add(generateReadWriteEntity("CC.CC.taskSending", 1));
//        list.add(generateReadWriteEntity("CC.CC.startSlot", details.getSlot()));
//        list.add(generateReadWriteEntity("CC.CC.endSlot", details.getShelf()));
//        miloService.writeToOpcWord(list);
        //生成工位任务，将吊装位的玻璃状态改位进笼中
        //修改吊装位的原片状态为103 出片中
        //修改出片任务状态
@@ -433,7 +402,7 @@
        if (CollectionUtils.isEmpty(loadStationList)) {
            log.info("1号上片位生成调度任务");
            RawGlassStorageDetails rawDetails = getRawGlassStorageDetailsBySize(usageVOS.get(0), usageVOS.size());
            if (CollectionUtils.isEmpty(loadStationList)) {
            if (rawDetails == null) {
                log.info("仓库内无匹配的玻璃");
                return Boolean.FALSE;
            }
@@ -487,7 +456,12 @@
                    RawGlassStorageDetails twoLoadStation = loadStationList.stream().filter(e -> e.getSlot().equals(loadStation.get(1))).findFirst().orElse(null);
                    if (null == twoLoadStation) {
                        //按照尺寸生成二号位上片任务信息
                        LoadGlassDeviceTask loadTask = loadGlassDeviceTaskService.queryTaskMessage(tableName);
                        S7DataSP loadTask = new S7DataSP();
                        if (stationCell == 5) {
                            loadTask = s7SerializerSPOne.read(S7DataSP.class);
                        } else {
                            loadTask = s7SerializerSPTwo.read(S7DataSP.class);
                        }
                        RawGlassStorageDetails rawDetails = null;
                        if (oneLoadStation.getRemainQuantity() > (loadTask.getTotalCount() + loadTask.getDamageCount())) {
                            usageVOS = upListMap.get("2");
@@ -513,7 +487,12 @@
                    } else {
                        //todo:当二号为的尺寸大于0时，是否执行调度任务，更换当前原片的尺寸，等待下一次任务的直接执行；还是继续等待，当尺寸不一样，等待一号工位的进出库调度任务。
                        if (twoLoadStation.getRemainQuantity() > 0) {
                            LoadGlassDeviceTask loadTask = loadGlassDeviceTaskService.queryTaskMessage(tableName);
                            S7DataSP loadTask = new S7DataSP();
                            if (stationCell == 5) {
                                loadTask = s7SerializerSPOne.read(S7DataSP.class);
                            } else {
                                loadTask = s7SerializerSPTwo.read(S7DataSP.class);
                            }
                            if (oneLoadStation.getRemainQuantity() > (loadTask.getTotalCount() + loadTask.getDamageCount())) {
                                usageVOS = upListMap.get("2");
                                if (CollectionUtils.isEmpty(usageVOS)) {
@@ -545,7 +524,6 @@
                            return Boolean.TRUE;
                        }
                    }
//                    return Boolean.FALSE;
                } else {
                    log.info("2号上片位仅剩空架子，1号上片位生成出库调度任务");
                    rawGlassStorageDetailsService.generateTask(loadStation.get(0), oneLoadStation.getShelf(), oneLoadStation.getShelf(), oneLoadStation.getRemainQuantity(), Const.RAW_GLASS_TASK_TYPE_DISPATCH);

 hangzhoumesParent/moduleService/GlassStorageModule/src/main/java/com/mes/s7/entity/S7DataCC.java

New file
@@ -0,0 +1,52 @@
package com.mes.s7.entity;

import com.github.xingshuangs.iot.common.enums.EDataType;
import com.github.xingshuangs.iot.protocol.s7.serializer.S7Variable;
import lombok.Data;

/**
 * @Author : zhoush
 * @Date: 2025/4/30 14:19
 * @Description:
 */
@Data
public class S7DataCC {

    @S7Variable(address = "DB38.0", type = EDataType.UINT16)
    private Integer request;

    @S7Variable(address = "DB38.2", type = EDataType.UINT16)
    private Integer requestId;

    @S7Variable(address = "DB38.10", type = EDataType.UINT16)
    private Integer reportWord;

    @S7Variable(address = "DB38.12", type = EDataType.UINT16)
    private Integer reportId;

    @S7Variable(address = "DB38.18", type = EDataType.UINT16)
    private Integer inCar;

    @S7Variable(address = "DB38.20", type = EDataType.UINT16)
    private Integer taskWord;

    @S7Variable(address = "DB38.22", type = EDataType.UINT16)
    private Integer taskId;

    @S7Variable(address = "DB38.24", type = EDataType.UINT16)
    private Integer startSlot;

    @S7Variable(address = "DB38.26", type = EDataType.UINT16)
    private Integer endSlot;

    @S7Variable(address = "DB38.28", type = EDataType.UINT16)
    private Integer taskSending;

    @S7Variable(address = "DB38.40", type = EDataType.UINT16)
    private Integer confirmation;

    @S7Variable(address = "DB38.42", type = EDataType.UINT16)
    private Integer confirmationId;


}

 hangzhoumesParent/moduleService/GlassStorageModule/src/main/java/com/mes/s7/entity/S7DataSP.java

New file
@@ -0,0 +1,44 @@
package com.mes.s7.entity;

import com.github.xingshuangs.iot.common.enums.EDataType;
import com.github.xingshuangs.iot.protocol.s7.serializer.S7Variable;
import lombok.Data;

/**
 * @Author : zhoush
 * @Date: 2025/4/30 14:19
 * @Description:
 */
@Data
public class S7DataSP {


    @S7Variable(address = "DB19.14", type = EDataType.UINT16)
    private Integer taskState;

    @S7Variable(address = "DB19.18", type = EDataType.UINT16)
    private Integer damageCount;

    @S7Variable(address = "DB19.20", type = EDataType.UINT16)
    private Integer rawGlassWidth;

    @S7Variable(address = "DB19.22", type = EDataType.UINT16)
    private Integer rawGlassHeight;

    @S7Variable(address = "DB19.24", type = EDataType.UINT16)
    private Integer slot;

    @S7Variable(address = "DB19.26", type = EDataType.UINT16)
    private Integer totalCount;

    @S7Variable(address = "DB19.28", type = EDataType.UINT16)
    private Integer finishCount;

    @S7Variable(address = "DB19.16.0", type = EDataType.BOOL)
    private Boolean taskRunning;

    @S7Variable(address = "DB19.30", type = EDataType.UINT16)
    private Integer inkageState;


}

 hangzhoumesParent/moduleService/GlassStorageModule/src/main/resources/application-prod.yml

@@ -5,7 +5,7 @@
      strict: false #设置严格模式,默认false不启动. 启动后在未匹配到指定数据源时候回抛出异常,不启动会使用默认数据源.
      datasource:
        northGlassMes:
          url: jdbc:mysql://10.153.19.150:3306/north_glass_mes?serverTimezone=GMT%2b8
          url: jdbc:mysql://10.153.19.150:3306/north_glass_mes?serverTimezone=GMT%2b8&allowMultiQueries=true
          username: root
          password: beibo.123/
          driver-class-name: com.mysql.cj.jdbc.Driver

 hangzhoumesParent/moduleService/GlassStorageModule/src/main/resources/application-yw.yml

@@ -23,7 +23,7 @@
    password: 123456
kangaroohy:
  milo:
    enabled: true
    enabled: false
    primary: default
    config:
      default:

 hangzhoumesParent/moduleService/GlassStorageModule/src/main/resources/application.yml

@@ -3,7 +3,7 @@

spring:
  profiles:
    active: dev
    active: yw
  application:
    name: glassStorage
  liquibase:

 hangzhoumesParent/moduleService/GlassStorageModule/src/main/resources/logback-spring.xml

New file
@@ -0,0 +1,169 @@
<?xml version="1.0" encoding="UTF-8"?>
<configuration scan="true" scanPeriod="10 seconds">
    <!-- logger上下文名称（根据业务修改） -->
    <contextName>glassStorage</contextName>

    <!-- 定义了一个名为serverName的属性，它的值来自于logging.file.name，如果没有找到该属性默认为MyServerName（根据业务修改） -->
    <springProperty name="serverName" source="logging.file.name" defaultValue="glassStorage"/>
    <springProperty name="logging.path" source="logging.file.path" defaultValue="././logs/"/>

    <!-- 彩色日志依赖的渲染类 -->
    <!-- 定义了一个名为clr的转换规则，它使用org.springframework.boot.logging.logback.ColorConverter类进行转换，这个元素通常用于将日志输出中的文本着色，以便更容易地区分不同的日志级别或其他信息 -->
    <conversionRule conversionWord="clr" converterClass="org.springframework.boot.logging.logback.ColorConverter"/>
    <!-- WhitespaceThrowableProxyConverter和ExtendedWhitespaceThrowableProxyConverter都是用于将异常信息转换为字符串，并将其中的换行符替换为空格，以便更容易地在日志输出中显示的类。它们之间的区别在于，ExtendedWhitespaceThrowableProxyConverter在输出异常信息时会包含更多的详细信息，例如异常的类名、方法名和行号等 -->
    <!-- 定义了一个名为wex的转换规则，它使用org.springframework.boot.logging.logback.WhitespaceThrowableProxyConverter类进行转换，这个元素通常用于将异常信息转换为字符串，并将其中的换行符替换为空格，以便更容易地在日志输出中显示 -->
    <conversionRule conversionWord="wex"
                    converterClass="org.springframework.boot.logging.logback.WhitespaceThrowableProxyConverter"/>
    <!-- 定义了一个名为wEx的转换规则，它使用org.springframework.boot.logging.logback.ExtendedWhitespaceThrowableProxyConverter类进行转换，这个元素通常用于将异常信息转换为字符串，并将其中的换行符替换为空格，以便更容易地在日志输出中显示 -->
    <conversionRule conversionWord="wEx"
                    converterClass="org.springframework.boot.logging.logback.ExtendedWhitespaceThrowableProxyConverter"/>

    <!-- 彩色日志格式 -->
    <!-- value值是日志输出模板， :-是属性名和其默认值之间的分隔符，作用与:相同 -->
    <!-- 定义日志输出格式的转换规则，%d{yyyy-MM-dd HH:mm:ss.SSS}表示日期和时间，%clr表示将输出文本着色，{faint}表示使用淡色 -->
    <!-- %5p表示日志级别输出右对齐，左边以空格填充 -->
    <!-- ${PID:- }表示进程ID，%clr表示将输出文本着色，{magenta}表示使用洋红色 -->
    <!-- -表示一个分隔符 -->
    <!-- %t：显示产生该日志的线程名；%15：若字符长度小于15，则左边用空格填充；%.15：若字符长度超过15，截去多余字符 -->
    <!-- %-40：若字符长度小于40，则右边用空格填充；%.40：若字符长度超过40，截去多余字符；logger{39}对应的是“logging.WARNING”级别。具体来说，Python的logging模块定义了以下几个级别（从低到高）：NOTSET、DEBUG、INFO、WARNING、ERROR、CRITICAL。因此，logger{39}表示的是WARNING级别，即日志记录器会记录所有WARNING级别及以上的日志信息 -->
    <!-- %m表示日志消息；%n表示换行符；${LOG_EXCEPTION_CONVERSION_WORD:-%wEx}表示异常信息。如果日志输出中包含异常信息，这个规则将会将其转换为字符串，并将其中的换行符替换为空格，以便更容易地在日志输出中显示 -->
    <property name="CONSOLE_LOG_PATTERN"
              value="${CONSOLE_LOG_PATTERN:-%clr(%d{yyyy-MM-dd HH:mm:ss.SSS}){faint} %clr(${LOG_LEVEL_PATTERN:-%5p}) %clr(${PID:- }){magenta} %clr(---){faint} %clr([%15.15t]){faint} %clr(%-40.40logger{39}){cyan} %clr(:){faint} %m%n${LOG_EXCEPTION_CONVERSION_WORD:-%wEx}}"/>

    <!--1. 输出到控制台-->
    <!-- 定义控制台日志输出的appender，class="ch.qos.logback.core.ConsoleAppender"表示使用Logback框架提供的ConsoleAppender类来输出日志到控制台 -->
    <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
        <!--此日志appender是为开发使用，只配置最底级别，控制台输出的日志级别是大于或等于此级别的日志信息-->
        <!-- 定义日志输出级别的过滤器，class="ch.qos.logback.classic.filter.ThresholdFilter"表示使用Logback框架提供的ThresholdFilter类来过滤日志输出，<level>debug</level>表示只输出debug级别及以上的日志 -->
        <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
            <level>debug</level>
        </filter>
        <encoder>
            <!-- ${CONSOLE_LOG_PATTERN}表示控制台日志输出格式，UTF-8表示编码格式 -->
            <Pattern>${CONSOLE_LOG_PATTERN}</Pattern>
            <!-- 设置字符集 -->
            <charset>UTF-8</charset>
        </encoder>
    </appender>
    <!--2. 输出到文档-->
    <!-- 2.1 level为 DEBUG 日志，时间滚动输出  -->
    <!-- 定义文件日志输出的appender，class="ch.qos.logback.core.rolling.RollingFileAppender"表示使用Logback框架提供的RollingFileAppender类来输出日志到文件 -->
    <appender name="DEBUG_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <!-- 正在记录的日志文档的路径及文档名 -->
        <file>${logging.path}/${serverName}/web_debug.log</file>
        <!--日志文档输出格式-->
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
            <charset>UTF-8</charset> <!-- 设置字符集 -->
        </encoder>
        <!-- 日志记录器的滚动策略，按日期，按大小记录 -->
        <!-- 定义日志文件滚动策略的标签，class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy"表示使用Logback框架提供的TimeBasedRollingPolicy类来定义日志文件的滚动策略 -->
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <!-- 日志归档 -->
            <!-- 定义日志文件名的模式。在这个模式中，${logging.path}表示日志文件的路径，%d{yyyy-MM-dd}表示日期格式，%i表示文件索引 -->
            <fileNamePattern>${logging.path}/${serverName}/web-debug-%d{yyyy-MM-dd}.%i.log</fileNamePattern>
            <!-- 定义日志文件滚动策略的标签，class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP"表示使用Logback框架提供的SizeAndTimeBasedFNATP类来定义日志文件的滚动策略，<maxFileSize>100MB</maxFileSize>表示日志文件的最大大小为100MB。这个滚动策略通常用于按照时间和文件大小滚动日志文件，以便更好地管理日志文件的大小和数量 -->
            <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                <maxFileSize>100MB</maxFileSize>
            </timeBasedFileNamingAndTriggeringPolicy>
            <!--日志文档保留天数-->
            <maxHistory>7</maxHistory>
        </rollingPolicy>
        <!-- 此日志文档只记录debug级别的 -->
        <!-- 定义日志输出级别的过滤器。在这个过滤器中，class="ch.qos.logback.classic.filter.LevelFilter"表示使用Logback框架提供的LevelFilter类来过滤日志输出，<level>debug</level>表示只输出debug级别及以上的日志 -->
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <level>debug</level>
            <!-- <onMatch>ACCEPT</onMatch>表示如果日志事件与过滤器匹配，则接受该事件，<onMismatch>DENY</onMismatch>表示如果日志事件与过滤器不匹配，则拒绝该事件 -->
            <onMatch>ACCEPT</onMatch>
            <onMismatch>DENY</onMismatch>
        </filter>
    </appender>
    <!-- 2.2 level为 INFO 日志，时间滚动输出  -->
    <appender name="INFO_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <!-- 正在记录的日志文档的路径及文档名 -->
        <file>${logging.path}/${serverName}/web_info.log</file>
        <!--日志文档输出格式-->
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
            <charset>UTF-8</charset>
        </encoder>
        <!-- 日志记录器的滚动策略，按日期，按大小记录 -->
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <!-- 天天日志归档路径以及格式 -->
            <fileNamePattern>${logging.path}/${serverName}/web-info-%d{yyyy-MM-dd}.%i.log</fileNamePattern>
            <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                <maxFileSize>100MB</maxFileSize>
            </timeBasedFileNamingAndTriggeringPolicy>
            <!--日志文档保留天数-->
            <maxHistory>7</maxHistory>
        </rollingPolicy>
        <!-- 此日志文档只记录info级别的 -->
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <level>info</level>
            <onMatch>ACCEPT</onMatch>
            <onMismatch>DENY</onMismatch>
        </filter>
    </appender>
    <!-- 2.3 level为 WARN 日志，时间滚动输出  -->
    <appender name="WARN_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <!-- 正在记录的日志文档的路径及文档名 -->
        <file>${logging.path}/${serverName}/web_warn.log</file>
        <!--日志文档输出格式-->
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
            <charset>UTF-8</charset> <!-- 此处设置字符集 -->
        </encoder>
        <!-- 日志记录器的滚动策略，按日期，按大小记录 -->
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <fileNamePattern>${logging.path}/${serverName}/web-warn-%d{yyyy-MM-dd}.%i.log</fileNamePattern>
            <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                <maxFileSize>100MB</maxFileSize>
            </timeBasedFileNamingAndTriggeringPolicy>
            <!--日志文档保留天数-->
            <maxHistory>7</maxHistory>
        </rollingPolicy>
        <!-- 此日志文档只记录warn级别的 -->
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <level>warn</level>
            <onMatch>ACCEPT</onMatch>
            <onMismatch>DENY</onMismatch>
        </filter>
    </appender>
    <!-- 2.4 level为 ERROR 日志，时间滚动输出  -->
    <appender name="ERROR_FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <!-- 正在记录的日志文档的路径及文档名 -->
        <file>${logging.path}/${serverName}/web_error.log</file>
        <!--日志文档输出格式-->
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern>
            <charset>UTF-8</charset> <!-- 此处设置字符集 -->
        </encoder>
        <!-- 日志记录器的滚动策略，按日期，按大小记录 -->
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <fileNamePattern>${logging.path}/${serverName}/web-error-%d{yyyy-MM-dd}.%i.log</fileNamePattern>
            <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                <maxFileSize>100MB</maxFileSize>
            </timeBasedFileNamingAndTriggeringPolicy>
            <!--日志文档保留天数-->
            <maxHistory>7</maxHistory>
        </rollingPolicy>
        <!-- 此日志文档只记录ERROR级别的 -->
        <filter class="ch.qos.logback.classic.filter.LevelFilter">
            <level>ERROR</level>
            <onMatch>ACCEPT</onMatch>
            <onMismatch>DENY</onMismatch>
        </filter>
    </appender>
    <!--     4.1 开发环境:打印控制台-->
    <!-- 用于在Spring Boot应用程序中配置日志记录的标签。在这个标签中，name="dev"表示这个配置文件只在dev环境中生效，<logger name="com.myClass.controller" level="debug"/>表示为com.myClass.controller（根据业务修改）这个包下的类配置日志输出级别为debug -->
    <!--    <springProfile name="dev">-->
    <!--        <logger name="com.myClass.controller" level="debug"/>-->
    <!--    </springProfile>-->
    <!-- 用于配置日志输出的标签。在这个标签中，level="info"表示日志输出级别为info，<appender-ref ref="CONSOLE"/>、<appender-ref ref="DEBUG_FILE"/>、<appender-ref ref="INFO_FILE"/>、<appender-ref ref="WARN_FILE"/>、<appender-ref ref="ERROR_FILE"/>表示将日志输出到不同的appender中，分别为控制台、debug文件、info文件、warn文件和error文件 -->
    <root level="info">
        <appender-ref ref="CONSOLE"/>
        <appender-ref ref="INFO_FILE"/>
        <appender-ref ref="WARN_FILE"/>
        <appender-ref ref="ERROR_FILE"/>
    </root>
</configuration>

 hangzhoumesParent/moduleService/LoadGlassModule/src/main/java/com/mes/config/S7Config.java

New file
@@ -0,0 +1,30 @@
package com.mes.config;

import com.github.xingshuangs.iot.protocol.s7.enums.EPlcType;
import com.github.xingshuangs.iot.protocol.s7.serializer.S7Serializer;
import com.github.xingshuangs.iot.protocol.s7.service.S7PLC;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @Author : zhoush
 * @Date: 2025/4/30 13:50
 * @Description:
 */
@Configuration
public class S7Config {
    @Bean(name = "s7SerializerSPOne")
    public S7Serializer s7SerializerSPOne() {
        S7PLC s7PLC = new S7PLC(EPlcType.S1200, "192.168.10.15");
//        S7PLC s7PLC = new S7PLC(EPlcType.S1500, "10.153.19.191");
        return S7Serializer.newInstance(s7PLC);
    }

    @Bean(name = "s7SerializerSPTwo")
    public S7Serializer s7SerializerSPTwo() {
        S7PLC s7PLC = new S7PLC(EPlcType.S1200, "192.168.10.21");
//        S7PLC s7PLC = new S7PLC(EPlcType.S1500, "10.153.19.191");
        return S7Serializer.newInstance(s7PLC);
    }

}

 hangzhoumesParent/moduleService/LoadGlassModule/src/main/java/com/mes/job/OpcLoadGlassTask.java

@@ -3,6 +3,7 @@
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.github.xingshuangs.iot.protocol.s7.serializer.S7Serializer;
import com.mes.common.config.Const;
import com.mes.engineering.entity.Engineering;
import com.mes.engineering.mapper.EngineeringMapper;
@@ -14,11 +15,14 @@
import com.mes.pp.service.OptimizeProjectService;
import com.mes.rawglassdetails.entity.RawGlassStorageDetails;
import com.mes.rawglassdetails.service.RawGlassStorageDetailsService;
import com.mes.s7.entity.S7DataSP;
import com.mes.uppattenusage.entity.UpPattenUsage;
import com.mes.uppattenusage.entity.vo.UpPattenUsageVO;
import com.mes.uppattenusage.mapper.UpPattenUsageMapper;
import lombok.extern.slf4j.Slf4j;
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;
import org.springframework.util.CollectionUtils;
@@ -52,6 +56,14 @@
    private UpPattenUsageMapper upPattenUsageMapper;
    @Resource
    private OptimizeProjectService optimizeProjectService;

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

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

    private static final List<Integer> LOAD_STATION_01 = Arrays.asList(101, 102);
    private static final List<Integer> LOAD_STATION_02 = Arrays.asList(103, 104);
@@ -109,6 +121,13 @@
    }

    private void opcLoadGlassChild(String tableName, Integer deviceId) {
        S7DataSP s7DataSP = new S7DataSP();
        if (tableName.equals(LOAD_GLASS_DEVICE_ONE_TASK)) {
            s7DataSP = s7SerializerSPOne.read(S7DataSP.class);
        } else {
            s7DataSP = s7SerializerSPTwo.read(S7DataSP.class);
        }
        log.info("{}上片线，当前上片位信息：{}", deviceId, s7DataSP);
        Engineering engineering = engineeringMapper.selectOne(new LambdaQueryWrapper<Engineering>()
                .eq(Engineering::getState, Const.ENGINEERING_RUNNING).eq(Engineering::getStationCell, deviceId));
        if (null == engineering) {
@@ -116,12 +135,12 @@
            return;
        }
        //任务暂停
        LoadGlassDeviceTask task = loadGlassDeviceTaskService.queryTaskMessage(tableName);
        if (0 == task.getInkageState()) {
            log.info("{}上片线，处于离线状态：{}，结束本地上片请求", deviceId, task.getInkageState());
        S7DataSP task = new S7DataSP();
        if ("0".equals(s7DataSP.getInkageState().toString())) {
            log.info("{}上片线，处于离线状态：{}，结束本地上片请求", deviceId, s7DataSP.getInkageState().toString());
            return;
        }
        if (task.getTaskRunning().equals(Const.ENGINEERING_RUNNING)) {
        if (s7DataSP.getTaskRunning()) {
            log.info("{}上片线，有正在执行的任务，结束本地上片请求", deviceId);
            return;
        }
@@ -156,11 +175,21 @@
            int number = Math.min(twoLoadStation.getRemainQuantity(), usageVOS.size());
            //生成上片任务
            task.setTotalCount(number);
            task.setTaskRunning(Const.ENGINEERING_RUNNING);
            task.setTaskRunning(Boolean.TRUE);
            task.setRawGlassWidth((int) usageVOS.get(0).getWidth());
            task.setRawGlassHeight((int) usageVOS.get(0).getHeight());
            task.setSlot(loadStation.get(1));
            loadGlassDeviceTaskService.updateTaskMessage(tableName, task);
            S7DataSP s7DataSPWrite = new S7DataSP();
            s7DataSPWrite.setTotalCount(number);
            s7DataSPWrite.setTaskRunning(Boolean.TRUE);
            s7DataSPWrite.setRawGlassWidth((int) usageVOS.get(0).getWidth());
            s7DataSPWrite.setRawGlassHeight((int) usageVOS.get(0).getHeight());
            s7DataSPWrite.setSlot(loadStation.get(1));
            if (LOAD_GLASS_ONE_DEVICE.equals(deviceId)) {
                s7SerializerSPOne.write(s7DataSPWrite);
            } else {
                s7SerializerSPTwo.write(s7DataSPWrite);
            }
            saveHistoryTask(task, deviceId);
            return;
        }
@@ -172,33 +201,51 @@
        //生成上片任务
        int number = Math.min(oneLoadStation.getRemainQuantity(), usageVOS.size());
        task.setTotalCount(number);
        task.setTaskRunning(Const.ENGINEERING_RUNNING);
        task.setTaskRunning(Boolean.TRUE);
        task.setRawGlassWidth((int) usageVOS.get(0).getWidth());
        task.setRawGlassHeight((int) usageVOS.get(0).getHeight());
        task.setSlot(loadStation.get(0));
        loadGlassDeviceTaskService.updateTaskMessage(tableName, task);
        S7DataSP s7DataSPWrite = new S7DataSP();
        s7DataSPWrite.setTotalCount(number);
        s7DataSPWrite.setTaskRunning(Boolean.TRUE);
        s7DataSPWrite.setRawGlassWidth((int) usageVOS.get(0).getWidth());
        s7DataSPWrite.setRawGlassHeight((int) usageVOS.get(0).getHeight());
        s7DataSPWrite.setSlot(loadStation.get(0));
        if (LOAD_GLASS_ONE_DEVICE.equals(deviceId)) {
            s7SerializerSPOne.write(s7DataSPWrite);
        } else {
            s7SerializerSPTwo.write(s7DataSPWrite);
        }
        saveHistoryTask(task, deviceId);
    }

    private void opcLoadGlassFinishChid(String tableName, Integer deviceId) {
        LoadGlassDeviceTask task = loadGlassDeviceTaskService.queryTaskMessage(tableName);
        if (task.getTaskRunning().equals(Const.ENGINEERING_NEW)) {
        S7DataSP s7DataSP = new S7DataSP();
        if (tableName.equals(LOAD_GLASS_DEVICE_ONE_TASK)) {
            s7DataSP = s7SerializerSPOne.read(S7DataSP.class);
        } else {
            s7DataSP = s7SerializerSPTwo.read(S7DataSP.class);
        }
        log.info("{}上片线，当前上片位信息：{}", deviceId, s7DataSP);
        if (s7DataSP.getTaskRunning().toString().equals(Const.ENGINEERING_NEW)) {
            log.info("无任务,结束");
            return;
        }
        if (task.getTaskState() <= 1) {
        if (Integer.parseInt(s7DataSP.getTaskState().toString()) <= 1) {
            log.info("任务正在执行,结束");
            return;
        }
        //获取任务完成情况
//         已完成数量  破损数量
        Integer finishCount = task.getFinishCount();
        Integer damageCount = task.getDamageCount();
        Integer finishCount = Integer.parseInt(s7DataSP.getFinishCount().toString());
        Integer damageCount = Integer.parseInt(s7DataSP.getDamageCount().toString());
        Integer slot = Integer.parseInt(s7DataSP.getSlot().toString());

        //更新当前架子上的原片剩余情况
        rawGlassStorageDetailsService.update(new UpdateWrapper<RawGlassStorageDetails>()
                .inSql("slot", "select slot from raw_glass_storage_station where enable_state = 1")
                .eq("slot", task.getSlot())
//                .eq("slot", task.getSlot())
                .eq("slot", slot)
                .eq("state", Const.RAW_GLASS_STATE_IN)
                .setSql("remain_quantity = remain_quantity - " + (finishCount + damageCount)));
        //更新工程下的原片数量 todo:sql待优化
@@ -210,12 +257,17 @@
                    .set(UpPattenUsage::getState, Const.LOAD_RAW_GLASS_SUCCESS));
        }
        //任务表数据情况
        task.setTaskRunning(0);
        task.setTotalCount(0);
        task.setRawGlassWidth(0);
        task.setRawGlassHeight(0);
        task.setSlot(0);
        loadGlassDeviceTaskService.updateTaskMessage(tableName, task);
        S7DataSP s7DataSPWrite = new S7DataSP();
        s7DataSPWrite.setTaskRunning(Boolean.FALSE);
        s7DataSPWrite.setTotalCount(0);
        s7DataSPWrite.setRawGlassWidth(0);
        s7DataSPWrite.setRawGlassHeight(0);
        s7DataSPWrite.setSlot(0);
        if (LOAD_GLASS_ONE_DEVICE.equals(deviceId)) {
            s7SerializerSPOne.write(s7DataSPWrite);
        } else {
            s7SerializerSPTwo.write(s7DataSPWrite);
        }
        loadGlassDeviceTaskHistoryService.update(new LambdaUpdateWrapper<LoadGlassDeviceTaskHistory>()
                .set(LoadGlassDeviceTaskHistory::getTaskState, Const.RAW_GLASS_TASK_SUCCESS)
                .eq(LoadGlassDeviceTaskHistory::getTaskState, Const.RAW_GLASS_TASK_NEW)
@@ -223,7 +275,7 @@
        );
    }

    private boolean saveHistoryTask(LoadGlassDeviceTask task, Integer deviceId) {
    private boolean saveHistoryTask(S7DataSP task, Integer deviceId) {
        LoadGlassDeviceTaskHistory taskHistory = new LoadGlassDeviceTaskHistory();
        BeanUtils.copyProperties(task, taskHistory);
        taskHistory.setStation(deviceId);

 hangzhoumesParent/moduleService/LoadGlassModule/src/main/java/com/mes/s7/entity/S7DataSP.java

New file
@@ -0,0 +1,44 @@
package com.mes.s7.entity;

import com.github.xingshuangs.iot.common.enums.EDataType;
import com.github.xingshuangs.iot.protocol.s7.serializer.S7Variable;
import lombok.Data;

/**
 * @Author : zhoush
 * @Date: 2025/4/30 14:19
 * @Description:
 */
@Data
public class S7DataSP {


    @S7Variable(address = "DB19.14", type = EDataType.UINT16)
    private Integer taskState;

    @S7Variable(address = "DB19.18", type = EDataType.UINT16)
    private Integer damageCount;

    @S7Variable(address = "DB19.20", type = EDataType.UINT16)
    private Integer rawGlassWidth;

    @S7Variable(address = "DB19.22", type = EDataType.UINT16)
    private Integer rawGlassHeight;

    @S7Variable(address = "DB19.24", type = EDataType.UINT16)
    private Integer slot;

    @S7Variable(address = "DB19.26", type = EDataType.UINT16)
    private Integer totalCount;

    @S7Variable(address = "DB19.28", type = EDataType.UINT16)
    private Integer finishCount;

    @S7Variable(address = "DB19.16.0", type = EDataType.BOOL)
    private Boolean taskRunning;

    @S7Variable(address = "DB19.30", type = EDataType.UINT16)
    private Integer inkageState;


}

 hangzhoumesParent/moduleService/LoadGlassModule/src/main/resources/application-prod.yml

@@ -5,7 +5,7 @@
      strict: false #设置严格模式,默认false不启动. 启动后在未匹配到指定数据源时候回抛出异常,不启动会使用默认数据源.
      datasource:
        northGlassMes:
          url: jdbc:mysql://10.153.19.150:3306/north_glass_mes?serverTimezone=GMT%2b8
          url: jdbc:mysql://10.153.19.150:3306/north_glass_mes?serverTimezone=GMT%2b8&allowMultiQueries=true
          username: root
          password: beibo.123/
          driver-class-name: com.mysql.cj.jdbc.Driver

 hangzhoumesParent/moduleService/LoadGlassModule/src/main/resources/application-yw.yml

@@ -33,7 +33,7 @@
    password: 123456
kangaroohy:
  milo:
    enabled: true
    enabled: false
    primary: default
    config:
      default:

 hangzhoumesParent/moduleService/LoadGlassModule/src/main/resources/application.yml

@@ -2,7 +2,7 @@
  port: 10015
spring:
  profiles:
    active: dev
    active: yw
  application:
    name: loadGlass
  liquibase:

 hangzhoumesParent/moduleService/TemperingGlassModule/src/main/java/com/mes/config/ModbusConfig.java

New file
@@ -0,0 +1,19 @@
package com.mes.config;

import com.github.xingshuangs.iot.protocol.modbus.service.ModbusTcp;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @Author : zhoush
 * @Date: 2025/4/30 13:50
 * @Description:
 */
@Configuration
public class ModbusConfig {
    @Bean("tempModbusTcp")
    public ModbusTcp modbusTcp() {
//        return new ModbusTcp("127.0.0.1");
        return new ModbusTcp("192.168.20.80");
    }
}

 hangzhoumesParent/moduleService/TemperingGlassModule/src/main/java/com/mes/config/S7Config.java

New file
@@ -0,0 +1,30 @@
package com.mes.config;

import com.github.xingshuangs.iot.protocol.s7.enums.EPlcType;
import com.github.xingshuangs.iot.protocol.s7.serializer.S7Serializer;
import com.github.xingshuangs.iot.protocol.s7.service.S7PLC;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @Author : zhoush
 * @Date: 2025/4/30 13:50
 * @Description:
 */
@Configuration
public class S7Config {
    @Bean(name = "s7SerializerGHOne")
    public S7Serializer s7SerializerGHOne() {
        S7PLC s7PLC = new S7PLC(EPlcType.S1500, "192.168.20.180");
//        S7PLC s7PLC = new S7PLC(EPlcType.S1500, "10.153.19.191");
        return S7Serializer.newInstance(s7PLC);
    }

    @Bean(name = "s7SerializerGHTwo")
    public S7Serializer s7SerializerGHTwo() {
        S7PLC s7PLC = new S7PLC(EPlcType.S1500, "192.168.20.180");
//        S7PLC s7PLC = new S7PLC(EPlcType.S1500, "10.153.19.191");
        return S7Serializer.newInstance(s7PLC);
    }

}

 hangzhoumesParent/moduleService/TemperingGlassModule/src/main/java/com/mes/job/OpcNGTemperingTask.java

@@ -2,6 +2,8 @@


import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
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.common.config.Const;
@@ -9,11 +11,13 @@
import com.mes.pp.entity.OptimizeHeatLayout;
import com.mes.pp.service.OptimizeHeatDetailService;
import com.mes.pp.service.OptimizeHeatLayoutService;
import com.mes.s7.entity.S7DataGHOne;
import com.mes.temperingglass.entity.TemperingGlassInfo;
import com.mes.temperingglass.service.TemperingGlassInfoService;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang.StringUtils;
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;

@@ -37,6 +41,15 @@
    @Autowired
    private OptimizeHeatDetailService optimizeHeatDetailService;

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

    @Autowired
    ModbusTcp tempModbusTcp;

    private Integer offset = 40001;

    /**
     * 摆片台请求进片逻辑处理
     * fixedRate : 上一个调用开始后再次调用的延时（不用等待上一次调用完成）
@@ -44,23 +57,29 @@
     */
    @Scheduled(fixedDelay = 1000)
    public void requestTemperingTask() throws Exception {
        ReadWriteEntity requestInTempering = miloService.readFromOpcUa("GH1S7.GH1S7.requestInTempering");//请求进片
        ReadWriteEntity requestTemperingId = miloService.readFromOpcUa("GH1S7.GH1S7.requestTemperingId");//请求进片 炉号ID
        Integer request = Integer.parseInt(requestInTempering.getValue().toString());
        Integer id = Integer.parseInt(requestTemperingId.getValue().toString());
        S7DataGHOne s7DataGHOne = s7SerializerGHOne.read(S7DataGHOne.class);
        log.info("读取到的GH1S7.GH1S7数据：{}", s7DataGHOne);
        Integer request = (int) s7DataGHOne.getRequestInTempering();
        Integer id = (int) s7DataGHOne.getRequestTemperingId();
        if (request == 0) {
            miloService.writeToOpcUa(generateReadWriteEntity("GH1S7.GH1S7.responseInTempering", 0));//允许送片清零
            s7SerializerGHOne.write(
                    S7DataGHOne.builder().responseInTempering(0).build()
            );
        } else {
            if (id == 0){
            if (id == 0) {
                log.info("炉号不能为0");
                return;
            }
            ReadWriteEntity placedNumber = miloService.readFromOpcUa("GH1S7.GH1S7.placedNumber");//已摆片数量
            String placedNumber = s7DataGHOne.getPlacedNumber().toString();//已摆片数量
            List<TemperingGlassInfo> glassList = temperingAgoService.selectGlassInfoById(id);
            if (Integer.parseInt(placedNumber.getValue().toString()) == glassList.size()) {
                miloService.writeToOpcUa(generateReadWriteEntity("GH1S7.GH1S7.responseInTempering", 1));//写入允许送片
            if (Integer.parseInt(placedNumber) == glassList.size()) {
                s7SerializerGHOne.write(
                        S7DataGHOne.builder().responseInTempering(1).build()
                );
            } else {
                miloService.writeToOpcUa(generateReadWriteEntity("GH1S7.GH1S7.responseInTempering", 2));//不满足进炉条件
                s7SerializerGHOne.write(
                        S7DataGHOne.builder().responseInTempering(2).build()
                );
            }
        }
    }
@@ -72,9 +91,12 @@
     */
    @Scheduled(fixedDelay = 1000)
    public void loadTemperingTask() throws Exception {
        ReadWriteEntity loadTemperingId = miloService.readFromOpcUa("GH1S7.GH1S7.loadTemperingId");//进片完成 炉号ID
        getNewTemperingID(Integer.parseInt(loadTemperingId.getValue().toString()));//进片完成 下发参数
        S7DataGHOne s7DataGHOne = s7SerializerGHOne.read(S7DataGHOne.class);
        log.info("读取到的GH1S7.GH1S7数据：{}", s7DataGHOne);
        Integer loadTemperingId = s7DataGHOne.getLoadTemperingId();//进片完成 炉号ID
        getNewTemperingID(loadTemperingId);//进片完成 下发参数
    }

    /**
     * 更新钢化小片表内的玻璃状态
     * fixedRate : 上一个调用开始后再次调用的延时（不用等待上一次调用完成）
@@ -82,11 +104,11 @@
     */
    @Scheduled(fixedDelay = 5000)
    public void updateTemperingTask() throws Exception {
        ReadWriteEntity furanchiIdEntity = miloService.readFromOpcUa("GH1.GH1.Furanch1Id");//进片完成 炉号ID
        if (StringUtils.isNotBlank(furanchiIdEntity.getValue()+"")){
            int temperingid = Integer.parseInt(furanchiIdEntity.getValue().toString());
        int furanchiIdEntity = tempModbusTcp.readUInt16(40461 - offset);
        if (StringUtils.isNotBlank(furanchiIdEntity + "")) {
            int temperingid = furanchiIdEntity;
            temperingAgoService.update(new LambdaUpdateWrapper<TemperingGlassInfo>().set(TemperingGlassInfo::getState, Const.TEMPERING_START)
                    .in(TemperingGlassInfo::getState, Const.TEMPERING_OUT, Const.TEMPERING_DROP).eq(TemperingGlassInfo::getTemperingLayoutId,temperingid));
                    .in(TemperingGlassInfo::getState, Const.TEMPERING_OUT, Const.TEMPERING_DROP).eq(TemperingGlassInfo::getTemperingLayoutId, temperingid));
        }


@@ -94,14 +116,14 @@

    //获取到炉号id执行参数下发任务
    private void getNewTemperingID(Integer temperingid) throws Exception {
        ReadWriteEntity autoStatus = miloService.readFromOpcUa("GH1.GH1.AutoStatus");
        if (1 != Integer.parseInt(autoStatus.getValue().toString())) {
        int autoStatus = tempModbusTcp.readUInt16(40451 - offset);
        if (1 != autoStatus) {
            log.info("当前为非联机状态，结束钢化下发参数任务");
            return;
        }
        ReadWriteEntity QandA = miloService.readFromOpcUa("GH1.GH1.QandA");
        ReadWriteEntity RecipeStatus = miloService.readFromOpcUa("GH1.GH1.RecipeStatus");
        if (1 == Integer.parseInt(QandA.getValue().toString()) && 2 == Integer.parseInt(RecipeStatus.getValue().toString())) {
        int QandA = tempModbusTcp.readUInt16(40422 - offset);
        int RecipeStatus = tempModbusTcp.readUInt16(40456 - offset);
        if (1 == QandA && 2 == RecipeStatus) {
            log.info("版面信息已经下发，并且已经匹配参数，结束钢化下发参数任务");
            return;
        }
@@ -129,17 +151,17 @@
            shape = shape > 10000 ? 10000 : shape;
            int workmode = 0; //工位数
            int furmode = 0; //双室/联室
            tempModbusTcp.writeUInt16(40408 - offset, temperingid);
            tempModbusTcp.writeUInt16(40409 - offset, glasstype);
            tempModbusTcp.writeUInt16(40411 - offset, process);
            tempModbusTcp.writeUInt16(40412 - offset, thiness);
            tempModbusTcp.writeUInt16(40413 - offset, loadingRate);
            tempModbusTcp.writeUInt16(40414 - offset, shape);
            tempModbusTcp.writeUInt16(40415 - offset, workmode);
            tempModbusTcp.writeUInt16(40416 - offset, furmode);

            miloService.writeToOpcUa(generateReadWriteEntity("GH1.GH1.TemperingId", temperingid));//写入炉号
            miloService.writeToOpcUa(generateReadWriteEntity("GH1.GH1.GlassType", glasstype));//写入玻璃类型
            miloService.writeToOpcUa(generateReadWriteEntity("GH1.GH1.Process", process));//写入钢化类型 全钢 半钢 防火
            miloService.writeToOpcUa(generateReadWriteEntity("GH1.GH1.Thickness", thiness));//写入厚度
            miloService.writeToOpcUa(generateReadWriteEntity("GH1.GH1.LoadingRate", loadingRate));//写入装载率
            miloService.writeToOpcUa(generateReadWriteEntity("GH1.GH1.Shape", shape));//写入大片比例
            miloService.writeToOpcUa(generateReadWriteEntity("GH1.GH1.WorkMode", workmode));//写入工位数
            miloService.writeToOpcUa(generateReadWriteEntity("GH1.GH1.FurnaceMode", furmode));//写入炉体工作方式
            log.info("炉号" + temperingid + "版面信息尝试下发");
       }
        }
    }



 hangzhoumesParent/moduleService/TemperingGlassModule/src/main/java/com/mes/job/PlcTemperingGlassTask.java

@@ -1,17 +1,20 @@
package com.mes.job;

import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.json.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.github.xingshuangs.iot.protocol.s7.serializer.S7Serializer;
import com.mes.common.config.Const;
import com.mes.damage.service.DamageService;
import com.mes.largenscreen.entity.PieChartVO;
import com.mes.s7.entity.S7DataGHTwo;
import com.mes.temperingglass.entity.TemperingGlassInfo;
import com.mes.temperingglass.service.TemperingGlassInfoService;
import com.mes.tools.WebSocketServer;
import lombok.extern.slf4j.Slf4j;
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;

@@ -20,6 +23,7 @@
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.stream.Collectors;

/**
 * @author SNG-010
@@ -29,46 +33,53 @@
public class PlcTemperingGlassTask {

    @Autowired
    private TemperingGlassInfoService temperingAgoService;
    private TemperingGlassInfoService temperingGlassInfoService;
    @Autowired
    private DamageService damageService;

    /**
     * fixedRate : 上一个调用开始后再次调用的延时（不用等待上一次调用完成）
     * fixedDelay : 上一个调用结束后再次调用的延时
     */
    @Autowired
    @Qualifier("s7SerializerGHTwo")
    private S7Serializer s7SerializerGHTwo;


    @Scheduled(fixedDelay = 1000)
    public void temperingGlassHome() {
        JSONObject jsonObject = new JSONObject();
        //正在等待进片的玻璃
        List<TemperingGlassInfo> waitingGlass = temperingAgoService.selectWaitingGlassByOpc();
        if (waitingGlass != null) {
            jsonObject.append("waitingGlass", waitingGlass);
        }

        //获取整在炉中的两个版图id
        List<TemperingGlassInfo> layoutId = temperingAgoService.selectLayoutId();
        //进炉中的玻璃
        if (!layoutId.isEmpty()) {
            List<TemperingGlassInfo> intoGlass = temperingAgoService.selectIntoGlass(layoutId.get(0));
            jsonObject.append("intoGlass", intoGlass);
            //进炉中的第二个版图
            if (layoutId.size() > 1) {
                List<TemperingGlassInfo> intoGlass2 = temperingAgoService.selectIntoGlass(layoutId.get(1));
                jsonObject.append("intoGlass2", intoGlass2);
        List<TemperingGlassInfo> waitingGlass = new ArrayList<>();
        try {
            waitingGlass = selectWaitingGlassByOpc();
            if (CollectionUtil.isNotEmpty(waitingGlass)) {
                jsonObject.append("waitingGlass", waitingGlass);
            }
        } catch (Exception e) {
            log.info("钢化前获取异常：{}", e.getMessage());
        }
        //出炉后的玻璃
        List<TemperingGlassInfo> outGlass = temperingAgoService.selectOutGlass();
        if (outGlass != null) {
            jsonObject.append("outGlass", outGlass);
        }
        try {
            List<TemperingGlassInfo> intoGlass = selectIntoGlass(waitingGlass);
            if (CollectionUtil.isNotEmpty(intoGlass)) {
                for (int i = 0; i < intoGlass.size(); i++) {
                    String jsonName = "intoGlass";
                    if (i != 0) {
                        jsonName = jsonName + i;
                    }
                    jsonObject.append(jsonName, temperingGlassInfoService.list(new LambdaQueryWrapper<TemperingGlassInfo>()
                            .eq(TemperingGlassInfo::getEngineerId, intoGlass.get(i).getEngineerId())
                            .eq(TemperingGlassInfo::getTemperingLayoutId, intoGlass.get(i).getTemperingLayoutId())));
                }

        //过旋转台钢化后的玻璃
        List<TemperingGlassInfo> overGlass = temperingAgoService.selectOverGlass();
        if (outGlass != null) {
            jsonObject.append("overGlass", overGlass);
            }
        } catch (Exception e) {
            log.info("钢化前获取异常：{}", e.getMessage());
        }
        try {
            //出炉后的玻璃
            List<TemperingGlassInfo> outGlass = temperingGlassInfoService.selectOutGlass();
            if (CollectionUtil.isNotEmpty(outGlass)) {
                jsonObject.append("outGlass", outGlass);
            }
        } catch (Exception e) {
            log.info("钢化前获取异常：{}", e.getMessage());
        }


@@ -88,7 +99,7 @@
    public void temperingIsRun() {
        JSONObject jsonObject = new JSONObject();
        //正在进行的任务
        List<TemperingGlassInfo> temperingTaskType = temperingAgoService.selectTaskType();
        List<TemperingGlassInfo> temperingTaskType = temperingGlassInfoService.selectTaskType();
        jsonObject.append("temperingTaskType", temperingTaskType);


@@ -111,23 +122,23 @@
        //大屏钢化信息
        Date startOfToday = new Date(LocalDate.now().atStartOfDay(ZoneId.systemDefault()).toInstant().toEpochMilli());

        Integer putGlass = temperingAgoService.count(
        Integer putGlass = temperingGlassInfoService.count(
                new QueryWrapper<TemperingGlassInfo>()
                        .eq("state", Const.TEMPERING_NEW)
                        .gt("create_time", startOfToday)
        );
        jsonObject.append("temperingTaskType", putGlass);
        //大屏钢化信息
        List<TemperingGlassInfo> temperingGlassInfoList = temperingAgoService.list(
        List<TemperingGlassInfo> temperingGlassInfoList = temperingGlassInfoService.list(
                new QueryWrapper<TemperingGlassInfo>()
                        .select("engineer_id" ,"tempering_layout_id")
                        .select("engineer_id", "tempering_layout_id")
                        .eq("state", Const.TEMPERING_START)
                        .gt("create_time", startOfToday)
                        .groupBy("engineer_id" ,"tempering_layout_id")
                        .groupBy("engineer_id", "tempering_layout_id")
        );
        jsonObject.append("temperingGlassInfoList", temperingGlassInfoList.size());
        //大屏钢化信息
        List<TemperingGlassInfo> temperingGlassInfoInList = temperingAgoService.list(
        List<TemperingGlassInfo> temperingGlassInfoInList = temperingGlassInfoService.list(
                new LambdaQueryWrapper<TemperingGlassInfo>()
                        .select(TemperingGlassInfo::getEngineerId, TemperingGlassInfo::getTemperingLayoutId) // 选择要去重的字段
                        .eq(TemperingGlassInfo::getState, Const.TEMPERING_DROP)
@@ -135,7 +146,7 @@
        );
        jsonObject.append("temperingGlassInfoInList", temperingGlassInfoInList.size());
        //钢化饼图数据
        List<PieChartVO> pieChartVOS = temperingAgoService.queryPieChart();
        List<PieChartVO> pieChartVOS = temperingGlassInfoService.queryPieChart();
        jsonObject.append("pieChartVOS", pieChartVOS);
        ArrayList<WebSocketServer> sendwServer = WebSocketServer.sessionMap.get("largenScreen");
        if (sendwServer != null) {
@@ -154,4 +165,53 @@
        }
    }


    /**
     * fixedRate : 上一个调用开始后再次调用的延时（不用等待上一次调用完成）
     * fixedDelay : 上一个调用结束后再次调用的延时
     */
    private List<TemperingGlassInfo> selectWaitingGlassByOpc() {
        //获取等待进炉中的玻璃信息
        try {
            S7DataGHTwo s7DataGHTwo = s7SerializerGHTwo.read(S7DataGHTwo.class);
            String engineerEntity = s7DataGHTwo.getF09EngineerId();
            Integer temperingLayoutIdEntity = s7DataGHTwo.getF09TemperingLayoutId();
            if (null == engineerEntity || null == temperingLayoutIdEntity) {
                engineerEntity = s7DataGHTwo.getF08EngineerId();
                temperingLayoutIdEntity = s7DataGHTwo.getF08TemperingLayoutId();
                if (null == engineerEntity || null == temperingLayoutIdEntity) {
                    log.info("获取参数异常，结束本次任务");
                    return new ArrayList<>();
                }
            }
            return temperingGlassInfoService.list(new LambdaQueryWrapper<TemperingGlassInfo>()
                    .eq(TemperingGlassInfo::getEngineerId, engineerEntity)
                    .eq(TemperingGlassInfo::getTemperingLayoutId, temperingLayoutIdEntity));
        } catch (Exception e) {
            log.info("获取钢化参数异常：{}", e);
            return new ArrayList<>();
        }
    }

    /**
     * 获取正在钢化的版图信息：获取3炉已经摆好的玻璃小片，排除正在摆的
     *
     * @param list
     * @return
     */
    private List<TemperingGlassInfo> selectIntoGlass(List<TemperingGlassInfo> list) {
        List<TemperingGlassInfo> temperingGlassInfoList = temperingGlassInfoService.queryEngineerAndLayoutId();
        log.info("钢化中获取到的数据为{}", temperingGlassInfoList);
        if (CollectionUtil.isEmpty(temperingGlassInfoList)) {
            return new ArrayList<>();
        }
        if (CollectionUtil.isEmpty(list)) {
            return temperingGlassInfoList;
        } else {
            String engineerId = list.get(0).getEngineerId();
            int temperingLayoutId = list.get(0).getTemperingLayoutId();
            List<TemperingGlassInfo> tempList = temperingGlassInfoList.stream().filter(e -> !(e.getEngineerId().equals(engineerId) && temperingLayoutId == e.getTemperingLayoutId())).collect(Collectors.toList());
            return tempList;
        }
    }
}

 hangzhoumesParent/moduleService/TemperingGlassModule/src/main/java/com/mes/s7/entity/S7DataGHOne.java

New file
@@ -0,0 +1,40 @@
package com.mes.s7.entity;

import com.github.xingshuangs.iot.common.enums.EDataType;
import com.github.xingshuangs.iot.protocol.s7.serializer.S7Variable;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.Arrays;
import java.util.List;

/**
 * @Author : zhoush
 * @Date: 2025/4/30 14:19
 * @Description:
 */
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class S7DataGHOne {


    @S7Variable(address = "DB99.0", type = EDataType.UINT16)
    private Integer requestInTempering;

    @S7Variable(address = "DB99.2", type = EDataType.UINT16)
    private Integer requestTemperingId;

    @S7Variable(address = "DB99.4", type = EDataType.UINT16)
    private Integer placedNumber;

    @S7Variable(address = "DB99.6", type = EDataType.UINT16)
    private Integer responseInTempering;

    @S7Variable(address = "DB99.8", type = EDataType.UINT16)
    private Integer loadTemperingId;

}

 hangzhoumesParent/moduleService/TemperingGlassModule/src/main/java/com/mes/s7/entity/S7DataGHTwo.java

New file
@@ -0,0 +1,28 @@
package com.mes.s7.entity;

import com.github.xingshuangs.iot.common.enums.EDataType;
import com.github.xingshuangs.iot.protocol.s7.serializer.S7Variable;
import lombok.Data;

/**
 * @Author : zhoush
 * @Date: 2025/4/30 14:19
 * @Description:
 */
@Data
public class S7DataGHTwo {


    @S7Variable(address = "DB110.32", type = EDataType.UINT16)
    private Integer f08TemperingLayoutId;

    @S7Variable(address = "DB110.80", type = EDataType.UINT16)
    private Integer f09TemperingLayoutId;

    @S7Variable(address = "DB110.34", type = EDataType.STRING,count = 10)
    private String f08EngineerId;

    @S7Variable(address = "DB110.82", type = EDataType.STRING,count = 10)
    private String f09EngineerId;

}

 hangzhoumesParent/moduleService/TemperingGlassModule/src/main/resources/application-yw.yml

@@ -37,7 +37,7 @@
    password: 123456
kangaroohy:
  milo:
    enabled: true
    enabled: false
    primary: default
    config:
      default:

 hangzhoumesParent/moduleService/TemperingGlassModule/src/main/resources/application.yml

@@ -2,7 +2,7 @@
  port: 10016
spring:
  profiles:
    active: dev
    active: yw
  application:
    name: temperingGlass
  liquibase:

 hangzhoumesParent/moduleService/hollowGlassModule/src/main/java/com/mes/config/ModbusConfig.java

New file
@@ -0,0 +1,32 @@
package com.mes.config;

import com.github.xingshuangs.iot.protocol.modbus.service.ModbusTcp;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @Author : zhoush
 * @Date: 2025/4/30 13:50
 * @Description:
 */
@Configuration
public class ModbusConfig {

    @Bean(name = "CMJ1ModbusTcp")
    public ModbusTcp CMJ1ModbusTcp() {
//        ModbusTcp modbusTcp=new ModbusTcp("127.0.0.1");
        ModbusTcp modbusTcp=new ModbusTcp("192.168.30.160");
        modbusTcp.setConnectTimeout(3000);
        return modbusTcp;

    }

    @Bean(name = "CMJ2ModbusTcp")
    public ModbusTcp CMJ2ModbusTcp() {
//        ModbusTcp modbusTcp=new ModbusTcp("127.0.0.1");
        ModbusTcp modbusTcp=new ModbusTcp("192.168.30.162");
        modbusTcp.setConnectTimeout(3000);
        return modbusTcp;
    }

}

 hangzhoumesParent/moduleService/hollowGlassModule/src/main/java/com/mes/config/S7Config.java

New file
@@ -0,0 +1,37 @@
package com.mes.config;

import com.github.xingshuangs.iot.protocol.s7.enums.EPlcType;
import com.github.xingshuangs.iot.protocol.s7.serializer.S7Serializer;
import com.github.xingshuangs.iot.protocol.s7.service.S7PLC;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @Author : zhoush
 * @Date: 2025/4/30 13:50
 * @Description:
 */
@Configuration
public class S7Config {
    @Bean(name = "s7SerializerZKDLPOne")
    public S7Serializer s7SerializerZKDLPOne() {
        S7PLC s7PLC = new S7PLC(EPlcType.S1500, "192.168.30.100");
//        S7PLC s7PLC = new S7PLC(EPlcType.S1500, "10.153.19.191");
        return S7Serializer.newInstance(s7PLC);
    }

    @Bean(name = "s7SerializerZKDLPTwo")
    public S7Serializer s7SerializerZKDLPTwo() {
        S7PLC s7PLC = new S7PLC(EPlcType.S1500, "192.168.30.100");
//        S7PLC s7PLC = new S7PLC(EPlcType.S1500, "10.153.19.191");
        return S7Serializer.newInstance(s7PLC);
    }

    @Bean(name = "s7SerializerZKQ2")
    public S7Serializer s7SerializerZKQ2() {
        S7PLC s7PLC = new S7PLC(EPlcType.S1500, "192.168.30.140");
//        S7PLC s7PLC = new S7PLC(EPlcType.S1500, "10.153.19.191");
        return S7Serializer.newInstance(s7PLC);
    }

}

 hangzhoumesParent/moduleService/hollowGlassModule/src/main/java/com/mes/hollow/entity/vo/HollowAllFlowCardVO.java

@@ -28,6 +28,10 @@
     * 是否直通
     */
    private Boolean isThroughSlot;
    /**
     * 已配对总数量
     */
    private int pairTotalCount;

    /**
     * 流程卡数据

 hangzhoumesParent/moduleService/hollowGlassModule/src/main/java/com/mes/hollow/entity/vo/HollowBigStorageDetailsQueryVO.java

@@ -25,5 +25,13 @@
     * 厚度
     */
    private int thickness;
    /**
     * 客户名称
     */
    private String customerName;
    /**
     * 产品名称
     */
    private String productName;

}

 hangzhoumesParent/moduleService/hollowGlassModule/src/main/java/com/mes/hollow/mapper/HollowGlassRelationInfoMapper.java

@@ -35,6 +35,6 @@
     * @param flowCardId
     * @return
     */
    OrderDetailsDTO queryProductNameByFlowCardId(@Param("flowCardId") String flowCardId);
    OrderDetailsDTO queryProductNameByFlowCardId(@Param("flowCardId") String flowCardId,@Param("productName") String productName,@Param("customerName") String customerName);
}


 hangzhoumesParent/moduleService/hollowGlassModule/src/main/java/com/mes/hollow/service/impl/HollowGlassRelationInfoServiceImpl.java

@@ -32,6 +32,7 @@
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
@@ -251,7 +252,7 @@

        Integer slotWidth = sysConfigService.queryConfigValue(ConstSysConfig.HOLLOW_SLOT_WIDTH);
//        Integer glassGap = sysConfigService.queryConfigValue(ConstSysConfig.HOLLOW_GLASS_GAP);
        Integer glassGap = getGlassGapByThickness(tempGlassList.get(0).getThickness());
        Integer glassGap = getGlassGapByThickness(glassInfo.getThickness());
        Integer outCarMaxSize = sysConfigService.queryConfigValue(ConstSysConfig.HOLLOW_OUT_CAR_SIZE);
        List<HollowGlassRelationInfo> relationInfoList = new ArrayList();
        List<List<HollowGlassRelationInfo>> tempHollowList = new ArrayList<>();
@@ -313,25 +314,34 @@
        }
        Map<String, List<HollowBigStorageCageDetails>> listMap = detailsList.stream().collect(Collectors.groupingBy(HollowBigStorageCageDetails::getFlowCardId));
        List<HollowAllFlowCardVO> resultList = new ArrayList<>();
        AtomicInteger pairTotalCount = new AtomicInteger();
        listMap.forEach((e, v) -> {
            HollowAllFlowCardVO hollowAllFlowCardVO = new HollowAllFlowCardVO();
            HollowBigStorageCageDetails cageDetails = v.get(0);
            //按照流程卡获取对应的产品名称
            OrderDetailsDTO orderDetails = baseMapper.queryProductNameByFlowCardId(cageDetails.getFlowCardId());
            OrderDetailsDTO orderDetails = baseMapper.queryProductNameByFlowCardId(cageDetails.getFlowCardId(), query.getProductName(), query.getCustomerName());
            if (null != orderDetails) {
                BeanUtils.copyProperties(orderDetails, hollowAllFlowCardVO);
                hollowAllFlowCardVO.setFlowCardId(e);
                if (cageDetails.getHollowSequence() == 0) {
                    hollowAllFlowCardVO.setIsThroughSlot(Boolean.TRUE);
                } else {
                    hollowAllFlowCardVO.setIsThroughSlot(Boolean.FALSE);
                }
                List<FlowCardGlassInfoDTO> flowCardInfoList = hollowBigStorageCageDetailsService.hollowIsAll(e, cageDetails.getTotalLayer(), Boolean.FALSE);
                log.info("获取到的流程卡信息为:{}", flowCardInfoList);
                if(CollectionUtil.isNotEmpty(flowCardInfoList)){
                    hollowAllFlowCardVO.setFlowCardGlassInfoDTOList(flowCardInfoList);
                    pairTotalCount.addAndGet(flowCardInfoList.get(0).getPairCount());
                }
                resultList.add(hollowAllFlowCardVO);
            }
            hollowAllFlowCardVO.setFlowCardId(e);
            if (cageDetails.getHollowSequence() == 0) {
                hollowAllFlowCardVO.setIsThroughSlot(Boolean.TRUE);
            } else {
                hollowAllFlowCardVO.setIsThroughSlot(Boolean.FALSE);
            }
            List<FlowCardGlassInfoDTO> flowCardInfoList = hollowBigStorageCageDetailsService.hollowIsAll(e, cageDetails.getTotalLayer(), Boolean.FALSE);
            hollowAllFlowCardVO.setFlowCardGlassInfoDTOList(flowCardInfoList);
            resultList.add(hollowAllFlowCardVO);
        });
        if (CollectionUtil.isEmpty(resultList)) {
            return new ArrayList<>();
        }
        sortFlowCardIdList(resultList);
        resultList.get(0).setPairTotalCount(pairTotalCount.get());
        return resultList;
    }

@@ -408,11 +418,6 @@
        }
        return sysConfigService.queryConfigValue(sysKey);
    }
    //    @Override
//    public List<LackDetailsDTO> queryLackByFlowCard(String flowCardId) {
//        List<LackDetailsDTO> lackDetailsList = this.baseMapper.queryLackByFlowCard(flowCardId);
//        return lackDetailsList;
//    }

    private void sortFlowCardIdList(List<HollowAllFlowCardVO> list) {
        Pattern pattern = Pattern.compile("^NG(\\d+)([A-Za-z]+)(\\d+)$");

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

@@ -1,5 +1,9 @@
package com.mes.job;

import com.github.xingshuangs.iot.common.buff.ByteReadBuff;
import com.github.xingshuangs.iot.common.buff.EByteBuffFormat;
import com.github.xingshuangs.iot.protocol.modbus.service.ModbusTcp;
import com.github.xingshuangs.iot.utils.ByteUtil;
import com.kangaroohy.milo.model.ReadWriteEntity;
import com.kangaroohy.milo.service.MiloService;
import com.mes.hollow.entity.vo.HollowGlassFormulaVO;
@@ -7,10 +11,12 @@
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang.StringUtils;
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;

import javax.annotation.Resource;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.List;

@@ -28,6 +34,43 @@
    @Autowired(required = false)
    MiloService miloService;

    @Autowired
    @Qualifier("CMJ1ModbusTcp")
    ModbusTcp CMJ1ModbusTcp;

    @Autowired
    @Qualifier("CMJ2ModbusTcp")
    ModbusTcp CMJ2ModbusTcp;

    private Integer offset = 40001;

    /**
     * 除膜机联机状态
     *
     * @throws Exception
     */
    @Scheduled(fixedDelay = 3000)
    public void filmRemoveStateOne() throws Exception {
        ModbusTcp modbusTcp = CMJ1ModbusTcp;
        try {
            modbusTcp.readUInt16(42001 - offset);
            log.info("除膜机1联机状态正常");
        } catch (Exception e) {
            log.error("除膜机1联机状态异常", e);
        }
    }

    @Scheduled(fixedDelay = 3000)
    public void filmRemoveStateTwo() throws Exception {
        ModbusTcp modbusTcp = CMJ2ModbusTcp;
        try {
            modbusTcp.readUInt16(42001 - offset);
            log.info("除膜机2联机状态正常");
        } catch (Exception e) {
            log.error("除膜机2联机状态异常", e);
        }
    }

    /**
     * 收到除膜机请求及玻璃id
     *
@@ -43,58 +86,86 @@
        hollowRemoveChildTask("CMJ2.CMJ2.");
    }

    public String readString(ModbusTcp modbusTcp, int address) {
        //
        byte[] bytes = new byte[20];
        for (int i = 0; i < 10; i++) {
            int res = modbusTcp.readUInt16(address + i);

            bytes[i * 2 + 1] = (byte) ((res >> 8) & 0xFF);
            bytes[i * 2] = (byte) (res & 0xFF);
        }
        int endIndex = 0;
        while (endIndex < bytes.length) {
            if (bytes[endIndex] == 0) {
                break;
            }
            endIndex++;
        }
        // 截取有效部分
        return new String(bytes, 0, endIndex);
    }

    private void hollowRemoveChildTask(String cell) throws Exception {
        ReadWriteEntity requestEntity = miloService.readFromOpcUa(cell + "mesControl");
        if ("0".equals(requestEntity.getValue() + "")) {
        ModbusTcp modbusTcp = null;
        if ("CMJ1.CMJ1.".equals(cell)) {
            modbusTcp = CMJ1ModbusTcp;
        } else {
            modbusTcp = CMJ2ModbusTcp;
        }
        if (!modbusTcp.checkConnected()) {
            log.info("除膜机{}未连接", cell);
            return;
        }
        String glassIdEntitys = readString(modbusTcp, 42003 - offset);
        log.info("除膜{}获取当前的玻璃id：{}", cell, glassIdEntitys);
        Integer requestEntity = modbusTcp.readUInt16(42001 - offset);
        if (0 == requestEntity) {
            log.info("当前除膜机为单机状态");
            return;
        }
        int request = Integer.parseInt(requestEntity.getValue() + "");
        int request = requestEntity;
        int flagRequest = request & 3;
        ReadWriteEntity glassIdEntity = miloService.readFromOpcUa(cell + "glassId");
        log.info("除膜{}获取当前的信号为：{},玻璃id:{}", cell, flagRequest, glassIdEntity);
        if (flagRequest != 3) {
            log.info("当前未收到请求玻璃id数据，结束任务");
            return;
        }

        log.info("除膜{}获取当前的玻璃id：{}", cell, glassIdEntity);
        if (null == glassIdEntity.getValue() || StringUtils.isBlank(glassIdEntity.getValue() + "")) {
        String glassIdEntity = readString(modbusTcp, 42003 - offset);
        log.info("除膜{}获取当前的信号为：{},玻璃id:{}", cell, flagRequest, glassIdEntity);
        if (null == glassIdEntity || StringUtils.isBlank(glassIdEntity)) {
            log.info("当前未收到玻璃id数据，结束任务");
            return;
        }
        log.info("当前需要除膜的玻璃id为：{}", glassIdEntity.getValue() + "");
        log.info("当前需要除膜的玻璃id为：{}", glassIdEntity);
        //按照玻璃id获取对应的任务id
        HollowGlassFormulaVO detailsVO = hollowFormulaDetailsService.queryFormulaDetailsByGlassId(glassIdEntity.getValue() + "", null, null);
        HollowGlassFormulaVO detailsVO = hollowFormulaDetailsService.queryFormulaDetailsByGlassId(glassIdEntity, null, null);
        if (null == detailsVO) {
            log.info("玻璃id不存在，请检查数据");
            return;
        }
        //按照任务id获取对应的配方信息

        List<ReadWriteEntity> ualist = new ArrayList<>();
        List<ReadWriteEntity> wordlist = new ArrayList<>();
        log.info("除膜{}获取玻璃{},是否除膜：{}", cell, glassIdEntity.getValue(), detailsVO.getFilmRemove());
        int Id = 0;
        log.info("除膜{}获取玻璃{},是否除膜：{}", cell, requestEntity, detailsVO.getFilmRemove());
        if (detailsVO.getFilmRemove() == 0) {
            // 10111011
            int sendId = request & 63;
            sendId = sendId + 4;
            wordlist.add(opcPlcStorageCageHollowTask.generateReadWriteEntity(cell + "mesControl", sendId));
            Id = sendId + 4;
            modbusTcp.writeUInt16(42001 - offset, sendId);
        } else {
            // 先将对应的位置为0，获得请求的玻璃数据， 然后将对应位值     110111011
            int sendId = request & 63;
            sendId = sendId + 4 + 64;
            wordlist.add(opcPlcStorageCageHollowTask.generateReadWriteEntity(cell + "mesControl", sendId));
            ualist.add(opcPlcStorageCageHollowTask.generateReadWriteEntity(cell + "glassTop", detailsVO.getTopRemove()));
            ualist.add(opcPlcStorageCageHollowTask.generateReadWriteEntity(cell + "glassBottom", detailsVO.getBottomRemove()));
            ualist.add(opcPlcStorageCageHollowTask.generateReadWriteEntity(cell + "glassLeft", detailsVO.getLeftRemove()));
            ualist.add(opcPlcStorageCageHollowTask.generateReadWriteEntity(cell + "glassRight", detailsVO.getRightRemove()));
            Id = sendId + 4 + 64;

            modbusTcp.writeUInt32(42019 - offset, detailsVO.getTopRemove());
            modbusTcp.writeUInt32(42021 - offset, detailsVO.getTopRemove());
            modbusTcp.writeUInt32(42023 - offset, detailsVO.getTopRemove());
            modbusTcp.writeUInt32(42025 - offset, detailsVO.getTopRemove());
        }
        ualist.add(opcPlcStorageCageHollowTask.generateReadWriteEntity(cell + "thickness", (int) (detailsVO.getThickness() * 10)));
        ualist.add(opcPlcStorageCageHollowTask.generateReadWriteEntity(cell + "firstLength", (int) (Math.max(detailsVO.getWidth(), detailsVO.getHeight())) * 10));
        ualist.add(opcPlcStorageCageHollowTask.generateReadWriteEntity(cell + "secondLength", (int) (Math.min(detailsVO.getWidth(), detailsVO.getHeight())) * 10));
        miloService.writeToOpcWord(wordlist);
        miloService.writeToOpcUa(ualist);
        modbusTcp.writeUInt32(42013 - offset, (int) (detailsVO.getThickness() * 10));
        modbusTcp.writeUInt32(42015 - offset, (int) (Math.max(detailsVO.getWidth(), detailsVO.getHeight())) * 10);
        modbusTcp.writeUInt32(42017 - offset, (int) (Math.min(detailsVO.getWidth(), detailsVO.getHeight())) * 10);
        modbusTcp.writeUInt16(42001 - offset, Id);
        return;
    }

@@ -114,8 +185,19 @@
    }

    public void finishHollowRemoveChildTask(String cell) throws Exception {
        ReadWriteEntity requestEntity = miloService.readFromOpcUa(cell + "mesControl");
        int request = Integer.parseInt(requestEntity.getValue() + "");
//        ReadWriteEntity requestEntity = miloService.readFromOpcUa(cell + "mesControl");
        ModbusTcp modbusTcp = null;
        if ("CMJ1.CMJ1.".equals(cell)) {
            modbusTcp = CMJ1ModbusTcp;
        } else {
            modbusTcp = CMJ2ModbusTcp;
        }
        if (!modbusTcp.checkConnected()) {
            log.info("除膜机{}未连接", cell);
            return;
        }
        int requestEntity = modbusTcp.readUInt16(42001 - offset);
        int request = requestEntity;
        int flagRequest = request & 9;
        if (flagRequest != 9) {
            log.info("当前未收到除膜机ID接收完成信号，结束任务");
@@ -124,9 +206,7 @@
        //向电气发送清楚信号
        int sendId = request & 251;
        log.info("{}收到除膜机ID接收完成信号，将写入数据完成置0,发送数据为：{}", cell, sendId);
        List<ReadWriteEntity> list = new ArrayList<>();
        list.add(opcPlcStorageCageHollowTask.generateReadWriteEntity(cell + "mesControl", sendId));
        miloService.writeToOpcWord(list);
        modbusTcp.writeUInt16(42001 - offset, sendId);
    }

}

 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";
    /**
@@ -90,52 +112,38 @@
    @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() + "")) {
        S7DataZKDLPOne s7DataZKDLPOne = s7SerializerZKDLPOne.read(S7DataZKDLPOne.class);
        log.info("进片任务读取s7DataZKDLPOne:{}", s7DataZKDLPOne);
        Boolean inkageEntity = s7DataZKDLPOne.getMesControl();
        if (true != inkageEntity) {
            log.info("当前为非联机状态，结束进片任务");
            return;
        }
        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() + "")) {
        String mesReplyEntity = s7DataZKDLPOne.getMesReply().toString();
        if ("1".equals(mesReplyEntity)) {
            log.info("有正在执行的任务，结束进片任务");
            return;
        }

        List<BigStorageCageTask> inTaskList = new ArrayList();
        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()) {
            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(Integer.parseInt(fromOpcUa));
                inTaskList.add(task);
                glassIdList.add(requestWord.getValue() + "");
                glassIdList.add(requestWord);
                continue;
            }
        }
@@ -149,7 +157,9 @@
            if (entry.getValue() > 1) {
                log.info("进片玻璃{}存在相同，结束本次任务", entry.getKey());
                //向plc发送报警:同一车进片玻璃存在相同
                miloService.writeToOpcWord(generateReadWriteEntity("DLP2A.DLP2A.alarmSignal", 2));
                s7DataZKDLPOne = new S7DataZKDLPOne();
                s7DataZKDLPOne.setAlramSignal(2);
                s7SerializerZKDLPOne.write(s7DataZKDLPOne);
                return;
            }
        }
@@ -158,7 +168,9 @@
        if (CollectionUtil.isNotEmpty(detailsList)) {
            log.info("理片笼存在相同的进片玻璃{}，结束本次任务", detailsList);
            //向plc发送报警:理片笼存在相同的进片玻璃
            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 +178,9 @@
        if (glassInfoList.size() != inTaskList.size()) {
            log.info("进片任务数量{}与玻璃数量{}不匹配，结束本次进片", inTaskList.size(), glassInfoList.size());
            //向plc发送报警:进片任务数量与系统查询到的玻璃数量不匹配
            miloService.writeToOpcWord(generateReadWriteEntity("DLP2A.DLP2A.alarmSignal", 8));
            s7DataZKDLPOne = new S7DataZKDLPOne();
            s7DataZKDLPOne.setAlramSignal(8);
            s7SerializerZKDLPOne.write(s7DataZKDLPOne);
            return;
        }

@@ -181,7 +195,9 @@
            if (count < entry.getValue()) {
                log.info("笼内格子剩余数量不足，结束本次进片");
                //向plc发送报警:笼内格子剩余数量不足
                miloService.writeToOpcWord(generateReadWriteEntity("DLP2A.DLP2A.alarmSignal", 16));
                s7DataZKDLPOne = new S7DataZKDLPOne();
                s7DataZKDLPOne.setAlramSignal(16);
                s7SerializerZKDLPOne.write(s7DataZKDLPOne);
                return;
            }
        }
@@ -195,7 +211,9 @@
            if (count > 0) {
                log.info("直通片台存在玻璃，结束本次进片");
                //向plc发送报警:直通片台存在玻璃，无法继续直通
                miloService.writeToOpcWord(generateReadWriteEntity("DLP2A.DLP2A.alarmSignal", 64));
                s7DataZKDLPOne = new S7DataZKDLPOne();
                s7DataZKDLPOne.setAlramSignal(64);
                s7SerializerZKDLPOne.write(s7DataZKDLPOne);
                return;
            }
        }
@@ -216,6 +234,7 @@

        Integer glassGap = sysConfigService.queryConfigValue(ConstSysConfig.HOLLOW_GLASS_GAP);
        try {
            log.info("开始计算目标格子,玻璃id有：{}", inTaskList);
            if (slotMaxHeight > Math.min(glassInfoList.get(0).getWidth(), glassInfoList.get(0).getHeight()) && glassInfoList.get(0).getThickness() < slotMaxthickness) {
                for (BigStorageCageTask task : inTaskList) {
                    GlassInfo info = glassListMap.get(task.getGlassId()).get(0);
@@ -227,7 +246,6 @@
                            .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);
@@ -260,7 +278,6 @@
            } else {
                BigStorageCageTask task = inTaskList.get(0);
                task.setTargetSlot(THROUGH_SLOT);
                bigStorageCageTaskService.updateTaskMessage("big_storage_cage_in_two_task", task);
                //存放历史任务
                HollowBigStorageCageHistoryTask historyTask = new HollowBigStorageCageHistoryTask();
                BeanUtils.copyProperties(task, historyTask);
@@ -295,45 +312,78 @@
        //历史数据入库
        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 (true != inkageEntity) {
            log.info("当前为非联机状态，结束进片任务");
            return;
        }
        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 = getOutTaskList(s7DataZKDLPTwo);

        if (CollectionUtil.isNotEmpty(outTaskList)) {
            log.info("有正在执行的出片任务，结束本次出片任务");
            return;
        }

        //获取空闲且领取任务的数据信息，没有任务直接走玻璃调度
        HashMap<Integer, ReadWriteEntity> map = new HashMap<>();
        HashMap<Integer, Boolean> map = new HashMap<>();
        try {
            map.put(930, miloService.readFromOpcUa("CMJ1.CMJ1.isFree"));
            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 {
            map.put(931, miloService.readFromOpcUa("ZKQ2.ZKQ2.isFree"));
            map.put(932, miloService.readFromOpcUa("ZKQ2.ZKQ2.isFree03"));
            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("二/三线线空闲状态获取异常");
@@ -342,9 +392,9 @@
        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 && entity) {
                    hollowGlassOutRelationInfo = hollowGlassOutRelationInfoService
                            .getOne(new LambdaQueryWrapper<HollowGlassOutRelationInfo>()
                                    .eq(HollowGlassOutRelationInfo::getCell, cell)
@@ -392,7 +442,6 @@
                        .set(HollowGlassOutRelationInfo::getState, Const.HOLLOW_FLOW_CARD_SUCCESS));
            }
        }
//        redisUtil.setCacheObject("dispatchHollowSwitch",true);
        //是否存在需要内部调度的格子:执行内部调度任务
        if (redisUtil.getCacheObject("dispatchHollowSwitch")) {
            //todo:获取笼内单格已经到齐的玻璃格子信息
@@ -434,33 +483,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;
            }
        }
@@ -532,30 +621,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());
@@ -576,7 +670,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());
@@ -604,7 +698,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) {
                //破损处理
@@ -671,11 +765,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) {
@@ -811,7 +906,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, "任务调度没有多余格子，结束调度任务");
                }

@@ -888,12 +986,53 @@
        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));
        }
        //清空任务表数据
        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);
@@ -901,6 +1040,7 @@
            history.setTaskType(taskType);
            return history;
        }).collect(Collectors.toList());
        log.info("历史任务保存{}", historyList);
        hollowBigStorageCageHistoryTaskService.saveBatch(historyList);
        log.info("将出片玻璃{}玻璃状态改为出片中", glassIds);
        hollowBigStorageCageDetailsService.update(new LambdaUpdateWrapper<HollowBigStorageCageDetails>()
@@ -909,7 +1049,9 @@
                .ne(HollowBigStorageCageDetails::getState, Const.GLASS_STATE_OUT)
                .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();
        }
@@ -926,9 +1068,6 @@
        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) -> {
@@ -953,4 +1092,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);
    }
}

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

@@ -3,6 +3,8 @@
import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.json.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
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.bigstoragecagetask.entity.BigStorageCageTask;
@@ -22,10 +24,15 @@
import com.mes.hollowtask.service.HollowBigStorageCageHistoryTaskService;
import com.mes.largenscreen.entity.PieChartVO;
import com.mes.largenscreen.entity.RunTime;
import com.mes.s7.entity.S7DataZKDLPOne;
import com.mes.s7.entity.S7DataZKDLPTwo;
import com.mes.s7.entity.S7DataZKExtra;
import com.mes.tools.WebSocketServer;
import com.mes.utils.RedisUtil;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang.StringUtils;
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;

@@ -64,23 +71,47 @@
    @Autowired(required = false)
    MiloService miloService;

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

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

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

    @Autowired
    @Qualifier("CMJ1ModbusTcp")
    ModbusTcp CMJ1ModbusTcp;

    @Autowired
    @Qualifier("CMJ2ModbusTcp")
    ModbusTcp CMJ2ModbusTcp;

    private Integer offset = 40001;

    @Resource
    RedisUtil redisUtil;

    @Scheduled(fixedDelay = 5000)
    public void hollowGlassTaskOne() {
        hollowGlassTaskChild(930, "CMJ1.CMJ1.isFree", "HollowGlassOne");
        hollowGlassTaskChild(930, CMJ1ModbusTcp.readUInt16(42027 - offset) + "", "HollowGlassOne");
    }

    @Scheduled(fixedDelay = 5000)
    public void hollowGlassTaskTwo() {
        hollowGlassTaskChild(931, "ZKQ2.ZKQ2.isFree", "HollowGlassTwo");
        S7DataZKExtra s7DataZKExtra = s7SerializerZKQ2.read(S7DataZKExtra.class);
        hollowGlassTaskChild(931, (s7DataZKExtra.getIsFree() ? 1 : 0) + "", "HollowGlassTwo");
    }

    @Scheduled(fixedDelay = 5000)
    public void hollowGlassTaskThree() {
        S7DataZKExtra s7DataZKExtra = s7SerializerZKQ2.read(S7DataZKExtra.class);
        //todo:暂无三线的空闲状态信号，临时标签空闲状态
        hollowGlassTaskChild(932, "ZKQ3.ZKQ3.isFree", "HollowGlassThree");
        hollowGlassTaskChild(932, (s7DataZKExtra.getIsFree03() ? 1 : 0) + "", "HollowGlassThree");
    }

    public void hollowGlassTaskChild(int cell, String isFreeTag, String websocketName) {
@@ -92,10 +123,9 @@
            List<HollowGlassQueueInfo> list = hollowGlassQueueInfoService.list(new LambdaQueryWrapper<HollowGlassQueueInfo>().in(HollowGlassQueueInfo::getRelationId, taskIdList));
            jsonObject.append("queueInfo", list);
        }

        try {
            //930空闲信号
            ReadWriteEntity freeOneRequestEntity = miloService.readFromOpcUa(isFreeTag);
            jsonObject.append("freeRequest", freeOneRequestEntity.getValue());
            jsonObject.append("freeRequest", isFreeTag);
        } catch (Exception e) {
            log.error("opc存在异常", e);
        }
@@ -139,6 +169,9 @@


    public void queryDataSource1(JSONObject jsonObject) throws Exception {
        S7DataZKDLPOne s7DataZKDLPOne = s7SerializerZKDLPOne.read(S7DataZKDLPOne.class);
        S7DataZKDLPTwo s7DataZKDLPTwo = s7SerializerZKDLPTwo.read(S7DataZKDLPTwo.class);
        S7DataZKExtra s7DataZKExtra = s7SerializerZKQ2.read(S7DataZKExtra.class);
        List<Double> carPostion = new ArrayList<>();
        carPostion.add(0.25);
        carPostion.add(0.5);
@@ -149,14 +182,46 @@
        try {
            //进片任务数据
            List<BigStorageTaskVO> inTaskList = new ArrayList();
            ReadWriteEntity fromOpcUa = miloService.readFromOpcUa("DLP2A.DLP2A.FROM1");
            for (int i = 1; i <= 6; i++) {
                ReadWriteEntity requestWord = miloService.readFromOpcUa("DLP2A.DLP2A.DI" + i);
                ReadWriteEntity targetSlotWord = miloService.readFromOpcUa("DLP2A.DLP2A.TO" + i);
                ReadWriteEntity stateWord = miloService.readFromOpcUa("DLP2A.DLP2A.STATE" + i);
                if (null != requestWord.getValue()) {
            String fromOpcUa = s7DataZKDLPOne.getFrom1().toString();
            for (int i = 0; i < 6; i++) {
                String requestWord = "";
                String stateWord = "";
                String targetSlotWord = "";
                switch (i) {
                    case 0:
                        requestWord = s7DataZKDLPOne.getId1();
                        stateWord = s7DataZKDLPOne.getState1().toString();
                        targetSlotWord = s7DataZKDLPOne.getTo1().toString();
                        break;
                    case 1:
                        requestWord = s7DataZKDLPOne.getId2();
                        stateWord = s7DataZKDLPOne.getState2().toString();
                        targetSlotWord = s7DataZKDLPOne.getTo2().toString();
                        break;
                    case 2:
                        requestWord = s7DataZKDLPOne.getId3();
                        stateWord = s7DataZKDLPOne.getState3().toString();
                        targetSlotWord = s7DataZKDLPOne.getTo3().toString();
                        break;
                    case 3:
                        requestWord = s7DataZKDLPOne.getId4();
                        stateWord = s7DataZKDLPOne.getState4().toString();
                        targetSlotWord = s7DataZKDLPOne.getTo4().toString();
                        break;
                    case 4:
                        requestWord = s7DataZKDLPOne.getId5();
                        stateWord = s7DataZKDLPOne.getState5().toString();
                        targetSlotWord = s7DataZKDLPOne.getTo5().toString();
                        break;
                    case 5:
                        requestWord = s7DataZKDLPOne.getId6();
                        stateWord = s7DataZKDLPOne.getState6().toString();
                        targetSlotWord = s7DataZKDLPOne.getTo6().toString();
                        break;
                }
                if (StringUtils.isNotEmpty(requestWord)) {
                    BigStorageTaskVO task = new BigStorageTaskVO();
                    task.setGlassId(requestWord.getValue() + "");
                    task.setGlassId(requestWord);
                    int isExistCount = hollowBigStorageCageDetailsService.count(new LambdaQueryWrapper<HollowBigStorageCageDetails>().in(HollowBigStorageCageDetails::getGlassId, task.getGlassId())
                            .in(HollowBigStorageCageDetails::getState, Const.GLASS_STATE_IN_ALL));
                    if (isExistCount > 0) {
@@ -164,9 +229,9 @@
                    } else {
                        task.setIsSame(0);
                    }
                    task.setStartSlot(Integer.parseInt(fromOpcUa.getValue() + ""));
                    task.setTargetSlot(Integer.parseInt(targetSlotWord.getValue() + ""));
                    task.setTaskState(Integer.parseInt(stateWord.getValue() + ""));
                    task.setStartSlot(Integer.parseInt(fromOpcUa));
                    task.setTargetSlot(Integer.parseInt(targetSlotWord));
                    task.setTaskState(Integer.parseInt(stateWord));
                    inTaskList.add(task);
                    continue;
                }
@@ -177,35 +242,86 @@
        }
        try {
            //进片联机
            ReadWriteEntity inkageEntity = miloService.readFromOpcUa("DLP2A.DLP2A.mesControl");
            jsonObject.append("inkageEntity", inkageEntity.getValue());
            Boolean inkageEntity = s7DataZKDLPOne.getMesControl();
            jsonObject.append("inkageEntity", inkageEntity);
            //进片请求
            ReadWriteEntity requestEntity = miloService.readFromOpcUa("DLP2A.DLP2A.RequestMes");
            jsonObject.append("requestEntity", requestEntity.getValue());
            String requestEntity = s7DataZKDLPOne.getRequestMes().toString();
            jsonObject.append("requestEntity", requestEntity);
            //启动命令
            ReadWriteEntity mesReplyEntity = miloService.readFromOpcUa("DLP2A.DLP2A.MesReply");
            jsonObject.append("mesReplyEntity", mesReplyEntity.getValue());
            String mesReplyEntity = s7DataZKDLPOne.getMesReply().toString();
            jsonObject.append("mesReplyEntity", mesReplyEntity);
            //出片联机
            ReadWriteEntity outInkageEntity = miloService.readFromOpcUa("DLP2B.DLP2B.mesControl");
            jsonObject.append("outInkageEntity", outInkageEntity.getValue());
            String outInkageEntity = s7DataZKDLPTwo.getMesControl().toString();
            jsonObject.append("outInkageEntity", outInkageEntity);
            //出片请求
            ReadWriteEntity outRequestEntity = miloService.readFromOpcUa("DLP2B.DLP2B.RequestMes");
            jsonObject.append("outRequestEntity", outRequestEntity.getValue());
            String outRequestEntity = s7DataZKDLPTwo.getRequestMes().toString();
            jsonObject.append("outInkageEntity", outInkageEntity);
            //930空闲信号
            ReadWriteEntity freeOneRequestEntity = miloService.readFromOpcUa("CMJ1.CMJ1.isFree");
            jsonObject.append("freeOneRequestEntity", freeOneRequestEntity.getValue());
            jsonObject.append("freeOneRequestEntity", CMJ1ModbusTcp.readUInt16(42027 - offset));
            //931空闲信号
            ReadWriteEntity freeTwoRequestEntity = miloService.readFromOpcUa("ZKQ2.ZKQ2.isFree");
            jsonObject.append("freeTwoRequestEntity", freeTwoRequestEntity.getValue());
            jsonObject.append("freeTwoRequestEntity", s7DataZKExtra.getIsFree());
            //932空闲信号
            ReadWriteEntity freeThreeRequestEntity = miloService.readFromOpcUa("ZKQ3.ZKQ3.isFree");
            jsonObject.append("freeThreeRequestEntity", freeThreeRequestEntity.getValue());
            jsonObject.append("freeThreeRequestEntity", s7DataZKExtra.getIsFree());
        } catch (Exception e) {
            //todo:不做任务处理
        }

        //出片任务数据
        List<BigStorageCageTask> outTaskList = bigStorageCageTaskService.queryTaskMessage("big_storage_cage_out_two_task");
        List<BigStorageCageTask> outTaskList = new ArrayList<>();
        for (int i = 0; i < 6; i++) {

            BigStorageCageTask bigStorageCageTask = new BigStorageCageTask();
            String glassId = "";
            Integer startSlot = 0;
            Integer targetSlot = 0;
            Integer taskState = 0;
            switch (i) {
                case 0:
                    glassId = s7DataZKDLPTwo.getId1();
                    startSlot = s7DataZKDLPTwo.getFrom1();
                    targetSlot = s7DataZKDLPTwo.getTo1();
                    taskState = s7DataZKDLPTwo.getState1();
                    ;
                    break;
                case 1:
                    glassId = s7DataZKDLPTwo.getId2();
                    startSlot = s7DataZKDLPTwo.getFrom2();
                    targetSlot = s7DataZKDLPTwo.getTo2();
                    taskState = s7DataZKDLPTwo.getState2();
                    break;
                case 2:
                    glassId = s7DataZKDLPTwo.getId3();
                    startSlot = s7DataZKDLPTwo.getFrom3();
                    targetSlot = s7DataZKDLPTwo.getTo3();
                    taskState = s7DataZKDLPTwo.getState3();
                    break;
                case 3:
                    glassId = s7DataZKDLPTwo.getId4();
                    startSlot = s7DataZKDLPTwo.getFrom4();
                    targetSlot = s7DataZKDLPTwo.getTo4();
                    taskState = s7DataZKDLPTwo.getState4();
                    break;
                case 4:
                    glassId = s7DataZKDLPTwo.getId5();
                    startSlot = s7DataZKDLPTwo.getFrom5();
                    targetSlot = s7DataZKDLPTwo.getTo5();
                    taskState = s7DataZKDLPTwo.getState5();
                    break;
                case 5:
                    glassId = s7DataZKDLPTwo.getId6();
                    startSlot = s7DataZKDLPTwo.getFrom6();
                    targetSlot = s7DataZKDLPTwo.getTo6();
                    taskState = s7DataZKDLPTwo.getState6();
                    break;
            }
            if (StringUtils.isNotEmpty(glassId)) {
                bigStorageCageTask.setGlassId(glassId);
                bigStorageCageTask.setStartSlot(startSlot);
                bigStorageCageTask.setTargetSlot(targetSlot);
                bigStorageCageTask.setTaskState(taskState);
                outTaskList.add(bigStorageCageTask);
            }
        }
        jsonObject.append("bigStorageCageDetailsOutTask", outTaskList);

        //调度开关

 hangzhoumesParent/moduleService/hollowGlassModule/src/main/java/com/mes/s7/entity/S7DataZKDLPOne.java

New file
@@ -0,0 +1,115 @@
package com.mes.s7.entity;

import com.github.xingshuangs.iot.common.enums.EDataType;
import com.github.xingshuangs.iot.protocol.s7.serializer.S7Variable;
import lombok.Data;

import java.util.Arrays;
import java.util.List;

/**
 * @Author : zhoush
 * @Date: 2025/4/30 14:19
 * @Description:
 */
@Data
public class S7DataZKDLPOne {


    @S7Variable(address = "DB3.2992.0", type = EDataType.BOOL)
    private Boolean mesControl;

    @S7Variable(address = "DB7.0", type = EDataType.UINT16)
    private Integer requestMes;

    @S7Variable(address = "DB7.2", type = EDataType.UINT16)
    private Integer mesReply;

    @S7Variable(address = "DB7.140", type = EDataType.UINT16)
    private Integer from1;

    @S7Variable(address = "DB7.142", type = EDataType.UINT16)
    private Integer from2;

    @S7Variable(address = "DB7.144", type = EDataType.UINT16)
    private Integer from3;

    @S7Variable(address = "DB7.146", type = EDataType.UINT16)
    private Integer from4;

    @S7Variable(address = "DB7.148", type = EDataType.UINT16)
    private Integer from5;

    @S7Variable(address = "DB7.150", type = EDataType.UINT16)
    private Integer from6;

    @S7Variable(address = "DB7.152", type = EDataType.UINT16)
    private Integer to1;

    @S7Variable(address = "DB7.154", type = EDataType.UINT16)
    private Integer to2;

    @S7Variable(address = "DB7.156", type = EDataType.UINT16)
    private Integer to3;

    @S7Variable(address = "DB7.158", type = EDataType.UINT16)
    private Integer to4;

    @S7Variable(address = "DB7.160", type = EDataType.UINT16)
    private Integer to5;

    @S7Variable(address = "DB7.162", type = EDataType.UINT16)
    private Integer to6;

    @S7Variable(address = "DB7.164", type = EDataType.UINT16)
    private Integer state1;

    @S7Variable(address = "DB7.166", type = EDataType.UINT16)
    private Integer state2;

    @S7Variable(address = "DB7.168", type = EDataType.UINT16)
    private Integer state3;

    @S7Variable(address = "DB7.170", type = EDataType.UINT16)
    private Integer state4;

    @S7Variable(address = "DB7.172", type = EDataType.UINT16)
    private Integer state5;

    @S7Variable(address = "DB7.174", type = EDataType.UINT16)
    private Integer state6;

    @S7Variable(address = "DB7.8", type = EDataType.STRING, count = 14)
    private String id1;

    @S7Variable(address = "DB7.30", type = EDataType.STRING, count = 14)
    private String id2;

    @S7Variable(address = "DB7.52", type = EDataType.STRING, count = 14)
    private String id3;

    @S7Variable(address = "DB7.74", type = EDataType.STRING, count = 14)
    private String id4;

    @S7Variable(address = "DB7.96", type = EDataType.STRING, count = 14)
    private String id5;

    @S7Variable(address = "DB7.118", type = EDataType.STRING, count = 14)
    private String id6;

    @S7Variable(address = "MW1002", type = EDataType.UINT16)
    private Integer alramSignal;

    public List<Integer> getStates() {
        return Arrays.asList(state1, state2, state3, state4, state5, state6);
    }

    public List<String> getIds() {
        return Arrays.asList(id1, id2, id3, id4, id5, id6);
    }

    public List<Integer> getTos() {
        return Arrays.asList(to1, to2, to3, to4, to5, to6);
    }

}

 hangzhoumesParent/moduleService/hollowGlassModule/src/main/java/com/mes/s7/entity/S7DataZKDLPTwo.java

New file
@@ -0,0 +1,116 @@
package com.mes.s7.entity;

import com.github.xingshuangs.iot.common.enums.EDataType;
import com.github.xingshuangs.iot.protocol.s7.serializer.S7Variable;
import lombok.Data;

import java.util.Arrays;
import java.util.List;

/**
 * @Author : zhoush
 * @Date: 2025/4/30 14:19
 * @Description:
 */
@Data
public class S7DataZKDLPTwo {


    @S7Variable(address = "DB3.2992.0", type = EDataType.BOOL)
    private Boolean mesControl;

    @S7Variable(address = "DB7.4", type = EDataType.UINT16)
    private Integer requestMes;

    @S7Variable(address = "DB7.6", type = EDataType.UINT16)
    private Integer mesReply;

    @S7Variable(address = "DB7.308", type = EDataType.UINT16)
    private Integer from1;

    @S7Variable(address = "DB7.310", type = EDataType.UINT16)
    private Integer from2;

    @S7Variable(address = "DB7.312", type = EDataType.UINT16)
    private Integer from3;

    @S7Variable(address = "DB7.314", type = EDataType.UINT16)
    private Integer from4;

    @S7Variable(address = "DB7.316", type = EDataType.UINT16)
    private Integer from5;

    @S7Variable(address = "DB7.318", type = EDataType.UINT16)
    private Integer from6;

    @S7Variable(address = "DB7.320", type = EDataType.UINT16)
    private Integer to1;

    @S7Variable(address = "DB7.322", type = EDataType.UINT16)
    private Integer to2;

    @S7Variable(address = "DB7.324", type = EDataType.UINT16)
    private Integer to3;

    @S7Variable(address = "DB7.326", type = EDataType.UINT16)
    private Integer to4;

    @S7Variable(address = "DB7.328", type = EDataType.UINT16)
    private Integer to5;

    @S7Variable(address = "DB7.330", type = EDataType.UINT16)
    private Integer to6;

    @S7Variable(address = "DB7.332", type = EDataType.UINT16)
    private Integer state1;

    @S7Variable(address = "DB7.334", type = EDataType.UINT16)
    private Integer state2;

    @S7Variable(address = "DB7.336", type = EDataType.UINT16)
    private Integer state3;

    @S7Variable(address = "DB7.338", type = EDataType.UINT16)
    private Integer state4;

    @S7Variable(address = "DB7.340", type = EDataType.UINT16)
    private Integer state5;

    @S7Variable(address = "DB7.342", type = EDataType.UINT16)
    private Integer state6;

    @S7Variable(address = "DB7.176", type = EDataType.STRING, count = 14)
    private String id1;

    @S7Variable(address = "DB7.198", type = EDataType.STRING, count = 14)
    private String id2;

    @S7Variable(address = "DB7.220", type = EDataType.STRING, count = 14)
    private String id3;

    @S7Variable(address = "DB7.242", type = EDataType.STRING, count = 14)
    private String id4;

    @S7Variable(address = "DB7.264", type = EDataType.STRING, count = 14)
    private String id5;

    @S7Variable(address = "DB7.286", type = EDataType.STRING, count = 14)
    private String id6;

    public List<Integer> getStates() {
        return Arrays.asList(state1, state2, state3, state4, state5, state6);
    }

    public List<String> getIds() {
        return Arrays.asList(id1, id2, id3, id4, id5, id6);
    }

    public List<Integer> getTos() {
        return Arrays.asList(to1, to2, to3, to4, to5, to6);
    }

    public List<Integer> getFroms() {
        return Arrays.asList(from1, from2, from3, from4, from5, from6);
    }

}

 hangzhoumesParent/moduleService/hollowGlassModule/src/main/java/com/mes/s7/entity/S7DataZKExtra.java

New file
@@ -0,0 +1,21 @@
package com.mes.s7.entity;

import com.github.xingshuangs.iot.common.enums.EDataType;
import com.github.xingshuangs.iot.protocol.s7.serializer.S7Variable;
import lombok.Data;

/**
 * @Author : zhoush
 * @Date: 2025/4/30 14:19
 * @Description:
 */
@Data
public class S7DataZKExtra {

    @S7Variable(address = "DB20.0.0", type = EDataType.BOOL)
    private Boolean isFree;

    @S7Variable(address = "DB20.0.1", type = EDataType.BOOL)
    private Boolean isFree03;

}

 hangzhoumesParent/moduleService/hollowGlassModule/src/main/resources/application-yw.yml

@@ -30,7 +30,7 @@
    password: 123456
kangaroohy:
  milo:
    enabled: true
    enabled: false
    primary: default
    config:
      default:

 hangzhoumesParent/moduleService/hollowGlassModule/src/main/resources/application.yml

@@ -3,16 +3,16 @@

spring:
  profiles:
    active: dev
    active: yw
  application:
    name: hollowGlass
  liquibase:
    enabled: false
#  task:
#    scheduling:
#      pool:
#        size: 10
#      thread-name-prefix: task-hollowGlass
  task:
    scheduling:
      pool:
        size: 3
      thread-name-prefix: task-hollowGlass
mybatis-plus:
  mapper-locations: classpath*:mapper/*.xml
#  configuration:

 hangzhoumesParent/moduleService/hollowGlassModule/src/main/resources/logback-spring.xml

@@ -1,7 +1,7 @@
<?xml version="1.0" encoding="UTF-8"?>
<configuration scan="true" scanPeriod="10 seconds">
    <!-- logger上下文名称（根据业务修改） -->
    <contextName>cacheVerticalGlass</contextName>
    <contextName>hollowGlass</contextName>

    <!-- 定义了一个名为serverName的属性，它的值来自于logging.file.name，如果没有找到该属性默认为MyServerName（根据业务修改） -->
    <springProperty name="serverName" source="logging.file.name" defaultValue="hollowGlass"/>

 hangzhoumesParent/moduleService/hollowGlassModule/src/main/resources/mapper/HollowGlassRelationInfoMapper.xml

@@ -132,11 +132,17 @@
    <select id="queryProductNameByFlowCardId" resultType="com.mes.hollow.entity.dto.OrderDetailsDTO">
        select t.product_name, t1.customer_name
        from sd.order_detail t
                 inner join sd.order t1 on t.order_id = t1.order_id
        inner join sd.order t1 on t.order_id = t1.order_id
        where (t.order_id, t.order_number) = (
            select min(order_id) as order_id, min(order_number) as order_number
            from pp.flow_card
            where process_id = #{flowCardId}
        select min(order_id) as order_id, min(order_number) as order_number
        from pp.flow_card
        where process_id = #{flowCardId}
        <if test="productName != null and productName != ''">
            and t.product_name like concat('%', #{productName}, '%')
        </if>
        <if test="customerName != null and customerName != ''">
            and t1.customer_name like concat('%', #{customerName}, '%')
        </if>
        )
        limit 1
    </select>