修改报表，界面添加查询流程卡个数，调整推送数据到前端的间隔

ZengTao

2025-03-28 f68d3c71819feb59e7a227a5d992b059b900916c

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

@@ -80,6 +80,12 @@
    @Value("${mes.max.secondLength}")
    private String secondLength;

    @Value("${mes.cache.cacheWidth}")
    private double cacheWidth;

    @Value("${mes.cache.cacheHeight}")
    private double cacheHeight;

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

@@ -94,7 +100,7 @@

    public static String engineerId = "";

    @Scheduled(fixedDelay = 1000)
    @Scheduled(fixedDelay = 500)
    public void plcHomeEdgTask() {
        Date startDate = new Date();
        log.info("本次任务开始执行时间：{}", startDate);
@@ -104,9 +110,22 @@
        String confirmationWrodValue = plcParameterObject.getPlcParameter("MES_confirmation_word").getValue();
        //A08  A09表示线路相同  可做等价  无数据转int异常
        String out08Glassstate = plcParameterObject.getPlcParameter("A08_glass_status").getValue();
        String out09Glassstate = plcParameterObject.getPlcParameter("A09_glass_status").getValue();
        String out10Glassstate = plcParameterObject.getPlcParameter("A10_glass_status").getValue();
        String confirmationWrodAddress = plcParameterObject.getPlcParameter("MES_confirmation_word").getAddress();
        String currentSlot = plcParameterObject.getPlcParameter("Current_slot").getValue();

        if ("1".equals(out09Glassstate)) {
            log.info("A09空闲");
            out08Glassstate = "1";
        }

//        taskRequestTypeValue = "2";
//        out08Glassstate = "1";
//        out10Glassstate = "1";
//        currentSlot = "1";
//        confirmationWrodValue = "0";
//        glassIdeValue = "P25021704|75|12";

        log.info("1、获取到的请求字为：{}，获取到的扫描ID为：{}，获取到的确认字为：{}，获取到的出片状态分别为：A09:{}、A10:{},当前格子号为：{}",
                taskRequestTypeValue, glassIdeValue, confirmationWrodValue, out08Glassstate, out10Glassstate, currentSlot);
@@ -124,21 +143,26 @@
            log.info("2、获取到的请求字不为0，将确认字不为0，直接结束");
            return;
        }
        if ("1".equals(taskRequestTypeValue)) {
            log.info("2、进片请求，且确认字为0，执行进片任务");
        boolean result = edgStorageCageDetailsService.inToVerify(glassIdeValue);
        if (!result) {
            log.info("此玻璃id已经进过");
            return;
        }
        if ("1".equals(taskRequestTypeValue) && result) {
            log.info("2、进片请求，且确认字为0，执行进片任务,扫码重复ID验证【有重复=false,无重复=true】：{}", result);
            inTo(glassIdeValue, confirmationWrodAddress, currentSlot);
        } else if ("2".equals(taskRequestTypeValue)) {
        } else if ("2".equals(taskRequestTypeValue) && result) {
            //09空闲 ：1      10空闲 ：2        都空闲：3    其他0
            log.info("2、出片请求，且确认字为0，执行出片任务");
            outTo(Integer.parseInt(out08Glassstate),
                    Integer.parseInt(out10Glassstate), confirmationWrodAddress, "", 0);
        } else if ("3".equals(taskRequestTypeValue)) {
                    Integer.parseInt(out10Glassstate), confirmationWrodAddress, "", Integer.parseInt(currentSlot));
        } else if ("3".equals(taskRequestTypeValue) && result) {
            log.info("2、进片和出片都空闲，执行出片任务");
            //加笼子里面是否有玻璃，有先出，无玻璃先进
            boolean outFlase = outTo(Integer.parseInt(out08Glassstate),
                    Integer.parseInt(out10Glassstate), confirmationWrodAddress, glassIdeValue, Integer.parseInt(currentSlot));
            log.info("出片任务是否完成：{},且玻璃id:{}不为空则执行进片任务", outFlase, glassIdeValue);
            if (!outFlase && StringUtils.isNotBlank(glassIdeValue)) {
            log.info("出片任务是否完成：{},且玻璃id:{}不为空则执行进片任务,扫码重复ID验证【有重复=false,无重复=true】：{}", outFlase, glassIdeValue, result);
            if (!outFlase && StringUtils.isNotBlank(glassIdeValue) && result) {
                inTo(glassIdeValue, confirmationWrodAddress, currentSlot);
            }
        }
@@ -147,7 +171,7 @@
    }


    @Scheduled(fixedDelay = 1000)
    @Scheduled(fixedDelay = 500)
    public void dealDamageTask() {
        Date startDate = new Date();
        log.info("卧式理片破损玻璃清除任务开始执行时间：{}", startDate);
@@ -164,9 +188,9 @@
                Damage damage = new Damage();
                damage.setGlassId(e.getGlassId());
                damage.setLine(e.getEndCell());
                damage.setWorkingProcedure("冷加工");
                damage.setWorkingProcedure("磨边");
                damage.setRemark("磨边前卧式理片");
                damage.setStatus(0);
                damage.setStatus(1);
                damage.setType(e.getTaskStatus());
                return damage;
            }).collect(Collectors.toList());
@@ -186,14 +210,31 @@
     */
    public void inTo(String glassId, String confirmationWrodAddress, String currentSlot) {
        log.info("1、按照玻璃id:{}获取玻璃小片信息,当前格子为:{}", glassId, currentSlot);

        GlassInfo feedGlassInfo = glassInfoService.getOne(
                new LambdaQueryWrapper<GlassInfo>()
                        .eq(GlassInfo::getGlassId, glassId)
        );
        if (Math.max(feedGlassInfo.getWidth(), feedGlassInfo.getHeight()) > cacheWidth ||
                Math.min(feedGlassInfo.getWidth(), feedGlassInfo.getHeight()) > cacheHeight
                || Math.min(feedGlassInfo.getWidth(), feedGlassInfo.getHeight()) < Integer.parseInt(minTwoFirstLength)
        ) {
            log.info("1.1、玻璃超过卧式理片尺寸范围:{}", feedGlassInfo);
            return;
        }

        //添加进片任务  查找空格
        EdgStorageCage nearestEmpty = edgStorageCageService.selectNearestEmpty(Integer.parseInt(currentSlot), Boolean.FALSE);
        Assert.isTrue(null != nearestEmpty, "格子已满");
        log.info("2、查询卧式理片笼里面的空格:{}", nearestEmpty);

        //查询玻璃并进行交换
        GlassInfo glassInfo = queryAndChangeGlass(glassId);
        //查询玻璃信息
        GlassInfo glassInfo = glassInfoService.getOne(new LambdaQueryWrapper<GlassInfo>().eq(GlassInfo::getGlassId, glassId));
        if (glassInfo == null) {
            return;
        }
        if ((glassInfo.getWidth() < Double.parseDouble(minTwoFirstLength) && glassInfo.getHeight() < Double.parseDouble(minTwoSecondLength)) || (glassInfo.getWidth() < Double.parseDouble(minTwoSecondLength) && glassInfo.getHeight() < Double.parseDouble(minTwoFirstLength))) {
            log.info("3、玻璃信息不符合进入理片笼最小尺寸，玻璃信息为{}", glassInfo);
            return;
        }
        log.info("4、将玻璃信息插入卧式理片笼,当前玻璃信息:{}", glassInfo);
@@ -203,6 +244,7 @@
        details.setSlot(nearestEmpty.getSlot());
        details.setDeviceId(nearestEmpty.getDeviceId());
        edgStorageCageDetailsService.save(details);
        damageService.deleteByGlassId(glassId);
        log.info("5、玻璃信息已存入理片笼详情表，玻璃信息为{}", details);
        //添加进片任务
        boolean taskCache = saveTaskCache(details.getGlassId(), 0, nearestEmpty.getSlot(), Const.GLASS_CACHE_TYPE_IN);
@@ -210,13 +252,6 @@

        S7object.getinstance().plccontrol.writeWord(confirmationWrodAddress, 1);
        log.info("7、发送确认字完成");
        Damage damage=new Damage();
        damage.setGlassId(glassInfo.getGlassId());
        damage.setWorkingProcedure("切割");
        damage.setLine(1001);
        damage.setType(1);
        damage.setRemark("进卧式理片");
        damageService.insertDamage(damage);

    }

@@ -226,25 +261,22 @@
     * @param glassId
     * @return
     */
    public GlassInfo queryAndChangeGlass(String glassId) {
    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, "玻璃信息不存在");
        if ((glassInfo.getWidth() < Double.parseDouble(minTwoFirstLength) && glassInfo.getHeight() < Double.parseDouble(minTwoSecondLength)) || (glassInfo.getWidth() < Double.parseDouble(minTwoSecondLength) && glassInfo.getHeight() < Double.parseDouble(minTwoFirstLength))) {
            log.info("3、玻璃信息不符合进入理片笼最小尺寸，玻璃信息为{}", glassInfo);
            return null;
        }
        //按照玻璃尺寸
        Assert.isFalse(null == glassInfo, "玻璃信息不存在");        //按照玻璃尺寸
        LambdaQueryWrapper<GlassInfo> queryWrapper = new LambdaQueryWrapper<GlassInfo>()
                .eq(GlassInfo::getWidth, glassInfo.getWidth())
                .eq(GlassInfo::getHeight, glassInfo.getHeight())
                .eq(GlassInfo::getThickness, glassInfo.getThickness())
                .eq(GlassInfo::getFilmsid, glassInfo.getFilmsid())
                .eq(GlassInfo::getFlowCardId, glassInfo.getFlowCardId())
                .eq(GlassInfo::getTotalLayer, glassInfo.getTotalLayer())
                .eq(GlassInfo::getLayer, glassInfo.getLayer())
                .eq(GlassInfo::getEngineerId, glassInfo.getEngineerId())
                .notInSql(GlassInfo::getGlassId, "select distinct glass_id from edg_storage_cage_details " +
                        "where engineer_id = '" + glassInfo.getEngineerId() + "' and width = " + glassInfo.getWidth() + " and height = " + glassInfo.getHeight())
                        "where engineer_id = '" + glassInfo.getEngineerId() + "' and width = " + glassInfo.getWidth() + " and height = " + glassInfo.getHeight()
                        + " and state != 100")
                .orderByAsc(GlassInfo::getTemperingLayoutId)
                .orderBy(Boolean.TRUE, sequenceOrder, GlassInfo::getTemperingFeedSequence)
                .last("Limit 1");
@@ -256,9 +288,52 @@
            glassInfo.setGlassId(swapGlassId);
            glassInfoService.updateById(swapGlassInfo);
            glassInfoService.updateById(glassInfo);
            return swapGlassInfo;
            return swapGlassId;
        }
        return glassInfo;
        return "";
    }


    /**
     * 查询卧式理片玻璃并进行交换
     *
     * @param glassId
     * @return
     */
    public void queryEdgAndChangeGlass(String glassId, String swapGlassId) {
        if (StringUtils.isBlank(swapGlassId)) {
            log.info("当前出笼玻璃不存在需要替换的玻璃");
            return;
        }
        //获取待出笼的玻璃
        EdgStorageCageDetails glassInfo = edgStorageCageDetailsService.getOne(new LambdaQueryWrapper<EdgStorageCageDetails>()
                .eq(EdgStorageCageDetails::getGlassId, glassId).eq(EdgStorageCageDetails::getState, Const.GLASS_STATE_IN));
//        获取待出笼的玻璃需要替换的玻璃信息
        EdgStorageCageDetails swapGlassDetailInfo = edgStorageCageDetailsService.getOne(new LambdaQueryWrapper<EdgStorageCageDetails>()
                .eq(EdgStorageCageDetails::getGlassId, swapGlassId).eq(EdgStorageCageDetails::getState, Const.GLASS_STATE_IN));

//      玻璃小片表中玻璃已经替换，更新卧理笼内现有的准备出笼的玻璃信息，
        if (null == swapGlassDetailInfo) {
            GlassInfo glassInfoBase = glassInfoService.getOne(new LambdaQueryWrapper<GlassInfo>()
                    .eq(GlassInfo::getGlassId, glassId));
            //需要替换的玻璃为存进卧理，仅需更新当前需要出笼的玻璃信息即可
            edgStorageCageDetailsService.update(new LambdaUpdateWrapper<EdgStorageCageDetails>()
                    .eq(EdgStorageCageDetails::getGlassId, glassId)
                    .set(EdgStorageCageDetails::getTemperingLayoutId, glassInfoBase.getTemperingLayoutId())
                    .set(EdgStorageCageDetails::getTemperingFeedSequence, glassInfoBase.getTemperingFeedSequence()));
        } else {
            //需要替换的玻璃都在卧理内，按照玻璃id对调玻璃信息：对调玻璃id即可
            edgStorageCageDetailsService.update(new LambdaUpdateWrapper<EdgStorageCageDetails>()
                    .eq(EdgStorageCageDetails::getId, glassInfo.getId())
                    .set(EdgStorageCageDetails::getTemperingLayoutId, swapGlassDetailInfo.getTemperingLayoutId())
                    .set(EdgStorageCageDetails::getTemperingFeedSequence, swapGlassDetailInfo.getTemperingFeedSequence())
            );
            edgStorageCageDetailsService.update(new LambdaUpdateWrapper<EdgStorageCageDetails>()
                    .eq(EdgStorageCageDetails::getId, swapGlassDetailInfo.getId())
                    .set(EdgStorageCageDetails::getTemperingLayoutId, glassInfo.getTemperingLayoutId())
                    .set(EdgStorageCageDetails::getTemperingFeedSequence, glassInfo.getTemperingFeedSequence())
            );
        }
    }

    /**
@@ -284,14 +359,27 @@
//        1.2.3、按照出片信息去详情表查询格子在笼子里面剩余相同尺寸的玻璃数据且以版图id、版序升序排序  取第一块玻璃出片
//        2、如果没有历史出片任务
//        2.1、出当前版图id最小版序最小的玻璃（问题：两条线都没有历史任务，出片时两条线的玻璃尺寸相同，是否找尺寸不同的）
        if ((out08Glassstate == 2 && out10Glassstate == 2) || (out08Glassstate == 0 && out10Glassstate == 0)) {
//        if ((out08Glassstate == 2 && out10Glassstate == 2) || (out08Glassstate == 0 && out10Glassstate == 0)) {
//            log.info("A09、A10为{},{}非自动状态，无法出片", out08Glassstate, out10Glassstate);
//            return Boolean.FALSE;
//        }
        if ((out08Glassstate == 2 && out10Glassstate == 2)) {
            log.info("A09、A10为{},{}非自动状态，无法出片", out08Glassstate, out10Glassstate);
            return Boolean.FALSE;
        }
        if ((out08Glassstate == 0 && out10Glassstate == 0)) {
            out10Glassstate = 1;
        }
        log.info("0、出片任务出的状态:A09:【{}】;A10:【{}】)", out08Glassstate, out10Glassstate);
        //定义出片玻璃信息
        int endcell = 0;
        EdgStorageCageDetails glassInfo = null;
        //当笼子已满时，不考虑卧式理片前的玻璃
        EdgStorageCage nearestEmpty = edgStorageCageService.selectNearestEmpty(currentSlot, Boolean.FALSE);
        if (nearestEmpty == null) {
            glassId = "";
        }

        boolean flag = queryMaxMinDiff(threshold);
        log.info("1、获取钢化版图是否超过阈值:{}", flag);
        if (flag) {
@@ -307,12 +395,23 @@
            endcell = queryLineByGlassInfo(a09EdgGlass, a10EdgGlass, glassInfo, out08Glassstate, out10Glassstate);
        } else {
            //按照状态判断两条线走那条线
            endcell = computerLineByState(out08Glassstate, out10Glassstate);

            GlassInfo glassInfos = glassInfoService.getOne(
                    new LambdaQueryWrapper<GlassInfo>()
                            .eq(GlassInfo::getGlassId, glassId)
            );
            if (glassInfos != null) {
                if (Math.max(glassInfos.getWidth(), glassInfos.getHeight()) > Integer.parseInt(firstLength) && out08Glassstate == 1) {
                    endcell = Const.A09_OUT_TARGET_POSITION;
                } else {
                    endcell = computerLineByState(out08Glassstate, out10Glassstate);
                }
            } else {
                endcell = computerLineByState(out08Glassstate, out10Glassstate);
            }
            if (out08Glassstate == 1 && out10Glassstate == 1) {
                EdgStorageCageDetails a09EdgGlass = queryGlassByTaskCache(Const.A09_OUT_TARGET_POSITION, Const.GLASS_CACHE_TYPE_OUT_ALL);
                EdgStorageCageDetails a10EdgGlass = queryGlassByTaskCache(Const.A10_OUT_TARGET_POSITION, Const.GLASS_CACHE_TYPE_OUT_ALL);
                if (a09EdgGlass == null && a10EdgGlass == null) {
                if (a09EdgGlass != null || a10EdgGlass != null) {
                    MPJQueryWrapper<EdgStorageCageDetails> wrapper = new MPJQueryWrapper<>();
                    wrapper.select("count(t.glass_id), t.width, t.height")
                            .eq("t.state", Const.GLASS_STATE_IN)
@@ -331,19 +430,21 @@
                    wrapper.last("order by count(t.glass_id) desc  limit 2");
                    List<EdgStorageCageDetails> list = edgStorageCageDetailsService.list(wrapper);
                    if (CollectionUtil.isEmpty(list)) {
                        log.info("笼子内没有找到合适的玻璃");
                        MPJQueryWrapper<GlassInfo> queryWrapper = new MPJQueryWrapper<GlassInfo>()
                                .selectAll(GlassInfo.class).eq("t.glass_id", glassId);
                        if (endcell == Const.A10_OUT_TARGET_POSITION) {
                            queryWrapper.innerJoin("(select glass_id, case when height <= width then width else height end as first_length, " +
                            queryWrapper.leftJoin("(select glass_id, case when height <= width then width else height end as first_length, " +
                                    "case when width < height then width else height end as second_length from edg_storage_cage_details) t1 " +
                                    "on t.glass_id = t1.glass_id and (t1.first_length between " + minTwoFirstLength + " and " + firstLength
                                    + " and t1.second_length between " + minTwoSecondLength + " and " + secondLength + ") ");
                        } else {
                            queryWrapper.innerJoin("(select glass_id, case when height <= width then width else height end as first_length, " +
                            queryWrapper.leftJoin("(select glass_id, case when height <= width then width else height end as first_length, " +
                                    "case when width < height then width else height end as second_length from edg_storage_cage_details) t1 " +
                                    "on t.glass_id = t1.glass_id and (t1.first_length >=" + minOneFirstLength + " and t1.second_length>=" + minOneSecondLength + ") ");
                        }
                        GlassInfo one = glassInfoService.getOne(queryWrapper);
                        log.info("找到合适的玻璃" + one);
                        if (one != null) {
                            EdgStorageCageDetails resultDetails = new EdgStorageCageDetails();
                            BeanUtils.copyProperties(one, resultDetails);
@@ -392,7 +493,11 @@
                }
            }
        }
        return saveOutGlassMessage(glassInfo, endcell, confirmationWrodAddress, glassId, currentSlot);
        if (endcell == Const.A09_OUT_TARGET_POSITION && Math.min(glassInfo.getWidth(), glassInfo.getHeight()) < Integer.parseInt(minOneFirstLength)) {
            log.info("尺寸不符合最大线最小尺寸{}", glassInfo);
            return Boolean.FALSE;
        }
        return saveOutGlassMessageBySlot(glassInfo, endcell, confirmationWrodAddress, glassId, currentSlot);
    }

    /**
@@ -634,6 +739,7 @@
            log.info("4、添加出片任务，玻璃id：{}，任务类型：{}，起始位置：{}，结束位置：{}", glassInfo.getGlassId(),
                    2, glassInfo.getSlot(), endcell);
            if (glassInfo.getGlassId().equals(glassId)) {

                log.info("5、直通任务,将玻璃信息插入卧式理片笼,当前玻璃信息:{}", glassInfo);
                EdgStorageCageDetails details = new EdgStorageCageDetails();
                BeanUtils.copyProperties(glassInfo, details);
@@ -643,7 +749,6 @@
                details.setSlot(nearestEmpty.getSlot());
                details.setState(Const.GLASS_STATE_OUT);
                edgStorageCageDetailsService.save(details);

                boolean taskCacheStatus = saveTaskCache(glassInfo.getGlassId(), nearestEmpty.getSlot(), endcell, Const.GLASS_CACHE_TYPE_THROUGH);
                log.info("6、添加出片任务是否完成：{}", taskCacheStatus);
            } else {
@@ -660,13 +765,87 @@
            log.info("7、添加出片玻璃尺寸信息到磨边前玻璃表是否完成：{}", glassSizeStatus);
            S7object.getinstance().plccontrol.writeWord(confirmationWrodAddress, 1);
            log.info("8、发送确认字已完成");
            Damage damage=new Damage();
            Damage damage = new Damage();
            damage.setGlassId(glassInfo.getGlassId());
            damage.setWorkingProcedure("切割");
            damage.setLine(1001);
            damage.setType(1);
            damage.setRemark("进卧式理片");
            damage.setRemark("过卧式理片");
            damageService.insertDamage(damage);
            damageService.deleteByGlassId(glassId);
            return Boolean.TRUE;
        }
        return Boolean.FALSE;
    }

    /**
     * 保存出片任务相关信息
     *
     * @param glassInfo
     * @param endcell
     * @param confirmationWrodAddress
     * @param glassId
     * @return
     */
    private boolean saveOutGlassMessageBySlot(EdgStorageCageDetails glassInfo, int endcell, String confirmationWrodAddress, String glassId, Integer currentSlot) {
        if (glassInfo != null) {
            log.info("4、添加出片任务，玻璃id：{}，任务类型：{}，起始位置：{}，结束位置：{}", glassInfo.getGlassId(),
                    2, glassInfo.getSlot(), endcell);
            if (glassInfo.getGlassId().equals(glassId)) {
                log.info("5、直通任务,将玻璃信息插入卧式理片笼,当前玻璃信息:{}", glassInfo);
                EdgStorageCageDetails details = new EdgStorageCageDetails();
                //玻璃信息替换
                String glassIdChange = queryAndChangeGlass(glassId);
                if (StringUtils.isBlank(glassIdChange)) {
                    BeanUtils.copyProperties(glassInfo, details);
                } else {
                    GlassInfo one = glassInfoService.getOne(new LambdaQueryWrapper<GlassInfo>().eq(GlassInfo::getGlassId, glassId));
                    BeanUtils.copyProperties(one, details);
                }
                EdgStorageCage nearestEmpty = edgStorageCageService.selectNearestEmpty(currentSlot, Boolean.TRUE);
                Assert.isTrue(null != nearestEmpty, "格子已满,无法执行直通任务");
                log.info("3、查询卧式理片笼里面的空格:{}", nearestEmpty);
                details.setSlot(nearestEmpty.getSlot());
                details.setState(Const.GLASS_STATE_OUT);
                edgStorageCageDetailsService.save(details);
                boolean taskCacheStatus = saveTaskCache(glassInfo.getGlassId(), nearestEmpty.getSlot(), endcell, Const.GLASS_CACHE_TYPE_THROUGH);
                log.info("6、添加出片任务是否完成：{}", taskCacheStatus);
            } else {
                log.info("5、非直通任务,将玻璃信息插入卧式理片笼,当前玻璃信息:{}", glassInfo);
                if (!glassInfo.getSlot().equals(currentSlot)) {
                    EdgStorageCageDetails currentGlass = edgStorageCageDetailsService.getOne(new LambdaQueryWrapper<EdgStorageCageDetails>()
                            .eq(EdgStorageCageDetails::getState, Const.GLASS_STATE_IN)
                            .eq(EdgStorageCageDetails::getSlot, currentSlot).eq(EdgStorageCageDetails::getWidth, glassInfo.getWidth())
                            .eq(EdgStorageCageDetails::getHeight, glassInfo.getHeight()).eq(EdgStorageCageDetails::getThickness, glassInfo.getThickness())
                    );
                    if (null != currentGlass) {
                        glassInfo = currentGlass;
                    }
                }
//                //玻璃信息替换
//                String glassIdChange = queryAndChangeGlass(glassInfo.getGlassId());
//                //处理在卧理内的玻璃信息：笼内的数据处理
//                queryEdgAndChangeGlass(glassInfo.getGlassId(), glassIdChange);
                LambdaUpdateWrapper<EdgStorageCageDetails> wrapper = new LambdaUpdateWrapper<>();
                wrapper.eq(EdgStorageCageDetails::getGlassId, glassInfo.getGlassId()).set(EdgStorageCageDetails::getState, Const.GLASS_STATE_OUT);
                edgStorageCageDetailsService.update(wrapper);
                log.info("5、更新出片玻璃的状态为{}", Const.GLASS_STATE_OUT);

                boolean taskCacheStatus = saveTaskCache(glassInfo.getGlassId(), glassInfo.getSlot(), endcell, Const.GLASS_CACHE_TYPE_OUT);
                log.info("6、添加出片任务是否完成：{}", taskCacheStatus);
            }
            boolean glassSizeStatus = saveGlassSize(glassInfo, endcell);
            log.info("7、添加出片玻璃尺寸信息到磨边前玻璃表是否完成：{}", glassSizeStatus);
            S7object.getinstance().plccontrol.writeWord(confirmationWrodAddress, 1);
            log.info("8、发送确认字已完成");
            Damage damage = new Damage();
            damage.setGlassId(glassInfo.getGlassId());
            damage.setWorkingProcedure("切割");
            damage.setLine(1001);
            damage.setType(1);
            damage.setRemark("过卧式理片");
            damageService.insertDamage(damage);
            damageService.deleteByGlassId(glassId);
            return Boolean.TRUE;
        }
        return Boolean.FALSE;
@@ -722,31 +901,41 @@
     * @return
     */
    private int computerLineByState(int out08Glassstate, int out10Glassstate) {
        if (out08Glassstate == 0) {
            if (out10Glassstate == 2) {
                return Const.A09_OUT_TARGET_POSITION;
            } else {
//        if (out08Glassstate == 0) {
//            if (out10Glassstate == 2) {
//                return Const.A09_OUT_TARGET_POSITION;
//            } else {
//                return Const.A10_OUT_TARGET_POSITION;
//            }
//        } else if (out08Glassstate == 1) {
//            return Const.A09_OUT_TARGET_POSITION;
//        } else {
//            return Const.A10_OUT_TARGET_POSITION;
//        }
        if (out10Glassstate == 0) {
            if (out08Glassstate == 2) {
                return Const.A10_OUT_TARGET_POSITION;
            } else {
                return Const.A09_OUT_TARGET_POSITION;
            }
        } else if (out08Glassstate == 1) {
            return Const.A09_OUT_TARGET_POSITION;
        } else {
        } else if (out10Glassstate == 1) {
            return Const.A10_OUT_TARGET_POSITION;
        } else {
            return Const.A09_OUT_TARGET_POSITION;
        }
    }

    @Scheduled(fixedDelay = 1000)
    @Scheduled(fixedDelay = 3000)
    public void CacheGlassTasks() {
        JSONObject jsonObject = new JSONObject();
        List<Map<String, Object>> currentCutTerritorys = edgStorageCageDetailsService.selectCutTerritory();
        jsonObject.append("currentCutTerritory", currentCutTerritorys);
        //log.info("本次识别版图{},++++{}",engineerId,currentCutTerritorys);
        //卧室缓存笼内信息
        List<Map<String, Object>> EdgStorageCageinfos = edgStorageCageService.selectEdgStorageCages();
        jsonObject.append("EdgStorageCageinfos", EdgStorageCageinfos);

        ArrayList<WebSocketServer> sendwServer = WebSocketServer.sessionMap.get("cacheGlass");
        if (sendwServer != null) {
            JSONObject jsonObject = new JSONObject();
            List<Map<String, Object>> currentCutTerritorys = edgStorageCageDetailsService.selectCutTerritory();
            jsonObject.append("currentCutTerritory", currentCutTerritorys);
            //log.info("本次识别版图{},++++{}",engineerId,currentCutTerritorys);
            //卧室缓存笼内信息
            List<Map<String, Object>> EdgStorageCageinfos = edgStorageCageService.selectEdgStorageCages();
            jsonObject.append("EdgStorageCageinfos", EdgStorageCageinfos);
            for (WebSocketServer webserver : sendwServer) {
                if (webserver != null) {
                    webserver.sendMessage(jsonObject.toString());
@@ -762,7 +951,7 @@
        }
    }

    @Scheduled(fixedDelay = 1000)
    @Scheduled(fixedDelay = 3000)
    public void cacheGlassIsRun() {
        JSONObject jsonObject = new JSONObject();
        //正在进行的任务
@@ -780,7 +969,7 @@
        }
    }

    @Scheduled(fixedDelay = 1000)
    @Scheduled(fixedDelay = 3000)
    public void CacheGlassTaskss() {
        JSONObject jsonObject = new JSONObject();
        //log.info("本次识别版图{},++++{}",engineerId,currentCutTerritorys);