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

ZengTao

2025-03-28 f68d3c71819feb59e7a227a5d992b059b900916c

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

@@ -22,7 +22,6 @@
import com.mes.bigstoragetask.service.BigStorageCageOutTaskService;
import com.mes.common.S7object;
import com.mes.common.config.Const;
import com.mes.common.utils.RedisUtil;
import com.mes.damage.entity.Damage;
import com.mes.damage.service.DamageService;
import com.mes.device.PlcParameterObject;
@@ -33,6 +32,8 @@
import com.mes.temperingglass.entity.TemperingGlassInfo;
import com.mes.temperingglass.service.TemperingGlassInfoService;
import com.mes.tools.S7control;
import com.mes.utils.RedisUtil;
import io.swagger.models.auth.In;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang.StringUtils;
import org.springframework.beans.BeanUtils;
@@ -98,6 +99,9 @@
    private String d01GlassId = "";
    private String d04GlassId = "";

    private List<BigStorageCageOutTask> allTask = new ArrayList<>();
    private List<BigStorageCageOutTask> notAllTask = new ArrayList<>();

    @Scheduled(fixedDelay = 300)
    public void plcToHomeEdgScan() {
        Date startDate = new Date();
@@ -116,6 +120,11 @@
        String d01ToMES = plcParameterObject.getPlcParameter("D01ToMES").getValue();
        String d04ToMES = plcParameterObject.getPlcParameter("D04ToMES").getValue();


//        d01Id="P25010108|37|8";
//        d04ToMES="1";
//        d01ToMES="1";

        log.info("1、获取d01Id扫描ID为：{}，请求字为{};获取d04Id扫描ID为：{}，请求字为{};", d01Id, d01ToMES, d04Id, d04ToMES);
        if (StringUtils.isBlank(d01ToMES) && StringUtils.isBlank(d04ToMES)) {
            log.info("两条线未收到进片任务，结束本次扫描进卧转立任务");
@@ -125,23 +134,68 @@
            log.info("两条线卧转立均在执行任务，结束本次扫描进卧转立任务");
            return;
        }
//        if (REQUEST_WORD.equals(d01ToMES)) {
//            List<BigStorageCageFeedTask> bigStorageCageFeedTasks = bigStorageCageFeedTaskService.list(
//                    new LambdaQueryWrapper<BigStorageCageFeedTask>()
//                            .gt(BigStorageCageFeedTask::getTargetSlot, 0)
//                            .eq(BigStorageCageFeedTask::getLine, Const.A09_OUT_TARGET_POSITION)
//                            .eq(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_NEW)
//                            .eq(BigStorageCageFeedTask::getGlassId, d01Id)
//            );
//            if (CollectionUtils.isNotEmpty(bigStorageCageFeedTasks)) {
//                S7object.getinstance().plccontrol.writeWord(mesD01Address, 1);
//            }
//            log.info("{}线再次发送进片启动", Const.A09_OUT_TARGET_POSITION);
//            return;
//        }
//        if (REQUEST_WORD.equals(d04ToMES)) {
//            List<BigStorageCageFeedTask> bigStorageCageFeedTasks = bigStorageCageFeedTaskService.list(
//                    new LambdaQueryWrapper<BigStorageCageFeedTask>()
//                            .gt(BigStorageCageFeedTask::getTargetSlot, 0)
//                            .eq(BigStorageCageFeedTask::getLine, Const.A10_OUT_TARGET_POSITION)
//                            .eq(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_NEW)
//                            .eq(BigStorageCageFeedTask::getGlassId, d01Id)
//            );
//            if (CollectionUtils.isNotEmpty(bigStorageCageFeedTasks)) {
//                S7object.getinstance().plccontrol.writeWord(mesD04Address, 1);
//            }
//            log.info("{}线再次发送进片启动", Const.A10_OUT_TARGET_POSITION);
//            return;
//        }
        //按照线路及玻璃id获取相邻两块玻璃 卧转立上的玻璃:  状态为0不操作（D01送片，0不操作，1允许送片），请求字为1， （02玻璃id为空或者卧转立未启动）
        if (!REQUEST_WORD.equals(mesD01Value) && REQUEST_WORD.equals(d01ToMES) && (StringUtils.isBlank(d02State) || !REQUEST_WORD.equals(d03State))) {
            if (!d01GlassId.equals(d01Id)) {
                judgeGlassTypeStatus(d01Id, Const.A09_OUT_TARGET_POSITION, mesD01Address);
                edgGlassTaskInfoService.update(new LambdaUpdateWrapper<EdgGlassTaskInfo>()
                        .set(EdgGlassTaskInfo::getStatus, Const.EDG_GLASS_SUCCESS).eq(EdgGlassTaskInfo::getGlassId, d01Id));
            List<BigStorageCageFeedTask> bigStorageCageFeedTasks = bigStorageCageFeedTaskService.list(
                    new LambdaQueryWrapper<BigStorageCageFeedTask>()
                            .gt(BigStorageCageFeedTask::getTargetSlot, 0)
                            .eq(BigStorageCageFeedTask::getLine, Const.A09_OUT_TARGET_POSITION)
                            .eq(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_UP)
            );
            if (CollectionUtils.isEmpty(bigStorageCageFeedTasks)) {
                if (!d01GlassId.equals(d01Id)) {
                    judgeGlassTypeStatus(d01Id, Const.A09_OUT_TARGET_POSITION, mesD01Address);
                    edgGlassTaskInfoService.update(new LambdaUpdateWrapper<EdgGlassTaskInfo>()
                            .set(EdgGlassTaskInfo::getStatus, Const.EDG_GLASS_SUCCESS).eq(EdgGlassTaskInfo::getGlassId, d01Id));
//                d01GlassId = d01Id;
                }
            }
        }
//        状态为0不操作（D01送片，0不操作，1允许送片），请求字为1， 卧转立未启动
        if (!REQUEST_WORD.equals(mesD04Value) && REQUEST_WORD.equals(d04ToMES) && !REQUEST_WORD.equals(d05State)) {
            if (!d04GlassId.equals(d04Id)) {
                judgeGlassTypeStatus(d04Id, Const.A10_OUT_TARGET_POSITION, mesD04Address);
                edgGlassTaskInfoService.update(new LambdaUpdateWrapper<EdgGlassTaskInfo>()
                        .set(EdgGlassTaskInfo::getStatus, Const.EDG_GLASS_SUCCESS).eq(EdgGlassTaskInfo::getGlassId, d04Id));
            List<BigStorageCageFeedTask> bigStorageCageFeedTasks = bigStorageCageFeedTaskService.list(
                    new LambdaQueryWrapper<BigStorageCageFeedTask>()
                            .gt(BigStorageCageFeedTask::getTargetSlot, 0)
                            .eq(BigStorageCageFeedTask::getLine, Const.A10_OUT_TARGET_POSITION)
                            .eq(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_UP)
            );
            if (CollectionUtils.isEmpty(bigStorageCageFeedTasks)) {
                if (!d04GlassId.equals(d04Id)) {
                    judgeGlassTypeStatus(d04Id, Const.A10_OUT_TARGET_POSITION, mesD04Address);
                    edgGlassTaskInfoService.update(new LambdaUpdateWrapper<EdgGlassTaskInfo>()
                            .set(EdgGlassTaskInfo::getStatus, Const.EDG_GLASS_SUCCESS).eq(EdgGlassTaskInfo::getGlassId, d04Id));
//                d04GlassId = d04Id;
                }
            }

        }
        Date endDate = new Date();
        log.info("大理片笼扫码任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime());
@@ -151,6 +205,7 @@
    public void plcToHomeEdgFreeCarTask() {
        Date startDate = new Date();
        log.info("大理片笼空车进片任务开始执行时间：{}", startDate);

        PlcParameterObject plcMesObject = S7object.getinstance().PlcMesObject;
        String mesD03Address = plcMesObject.getPlcParameter("MESToD03").getValue();
        String mesD05Address = plcMesObject.getPlcParameter("MESToD05").getValue();
@@ -180,13 +235,21 @@
        }
        if (!REQUEST_WORD.equals(d03ToMES) && !REQUEST_WORD.equals(d05ToMES)) {
            Date endDate = new Date();
            log.info("卧转立没有送片请求，结束送片任务，任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime());
            log.info("卧转立第一次没有送片请求，结束送片任务，任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime());
            return;
        }
//        List<Integer> lines=new ArrayList<>();
//        if(REQUEST_WORD.equals(d03ToMES)){
//            lines.add(Const.A09_OUT_TARGET_POSITION);
//        }
//        if(REQUEST_WORD.equals(d05ToMES)){
//            lines.add(Const.A10_OUT_TARGET_POSITION);
//        }
        LambdaQueryWrapper<BigStorageCageFeedTask> wrapper = new LambdaQueryWrapper<BigStorageCageFeedTask>()
                .eq(BigStorageCageFeedTask::getTaskType, Const.BIG_STORAGE_IN_RUN)
                .and(e -> e.isNull(BigStorageCageFeedTask::getTargetSlot).or().eq(BigStorageCageFeedTask::getTargetSlot, Const.OUT_TARGET_POSITION_ZERO))
                .eq(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_UP);
//                .in(BigStorageCageFeedTask::getLine,lines);
        //获取可以启动卧转立的任务线路
        List<BigStorageCageFeedTask> feedTaskList = bigStorageCageFeedTaskService.list(wrapper);
        if (CollectionUtils.isNotEmpty(feedTaskList)) {
@@ -224,6 +287,8 @@
                //获取卧转立剩余宽度
                if (computeIsRun(lineFirst, lineGlassId)) {
                    computeTargetByLine(lineFirst);
                } else {
                    log.info("当前线路：{}，有扫码玻璃：{}", lineFirst, lineGlassId);
                }
            }
            Date endDate = new Date();
@@ -233,7 +298,8 @@
        //两条先均可执行进片任务，判断两条线是否进片请求是否都为空
        if (StringUtils.isBlank(d01Id) && StringUtils.isBlank(d04Id)) {
            //比较最早一片任务的版图id及版序 求出卧转立的线路
            Integer line = getStartLine();
//            Integer line = getStartLine();
            Integer line = lineList.get(0);
            //计算任务表进片格子 发送进片任务
            computeTargetByLine(line);
            Date endDate = new Date();
@@ -263,13 +329,14 @@
            computeTargetByLine(outLine);
        }
        Date endDate = new Date();

        log.info("大理片笼空车进片任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime());
    }

    @Scheduled(fixedDelay = 10000)
    @Scheduled(fixedDelay = 5000)
    public void plcToHomeEdgOutTask() {
        Date startDate = new Date();
        log.info("大理片笼空车进片任务开始执行时间：{}", startDate);
        log.info("大理片笼出片任务开始执行时间：{}", startDate);
        PlcParameterObject plcMesObject = S7object.getinstance().PlcMesObject;
        String e02State = plcMesObject.getPlcParameter("E02State").getValue();
        if (REQUEST_WORD.equals(e02State)) {
@@ -284,16 +351,20 @@
            return;
        }
        if (redisUtil.getCacheObject("temperingSwitch")) {
//        if(true){
            //是否有正在钢化的玻璃
            List<TemperingGlassInfo> temperingGlassInfoList = temperingGlassInfoService.selectJoinList(TemperingGlassInfo.class, new MPJLambdaWrapper<TemperingGlassInfo>()
                    .selectAll(TemperingGlassInfo.class)
                    .leftJoin(BigStorageCageOutTask.class, BigStorageCageOutTask::getGlassId, TemperingGlassInfo::getGlassId)
                    .leftJoin(BigStorageCageOutTask.class, on -> on
                            .eq(TemperingGlassInfo::getGlassId, BigStorageCageOutTask::getGlassId)
                            .ne(BigStorageCageOutTask::getTaskState, Const.BIG_STORAGE_OUT_SUCCESS))
                    .eq(TemperingGlassInfo::getState, Const.TEMPERING_NEW)
                    .isNull(BigStorageCageOutTask::getGlassId)
                    .orderBy(Boolean.TRUE, sequenceOrder, TemperingGlassInfo::getTemperingFeedSequence));
            log.info("查询的出片任务：{}", temperingGlassInfoList);
            if (CollectionUtils.isNotEmpty(temperingGlassInfoList)) {
                log.info("有正在出片的钢化任务");
                computeOutMoreGlassInfo(temperingGlassInfoList, Boolean.TRUE, mesToPLCAddress);
                computeOutMoreGlassInfo(temperingGlassInfoList, Boolean.TRUE, 1);
                Date endDate = new Date();
                log.info("大理片笼出片任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime());
                return;
@@ -306,7 +377,7 @@
                    .orderByAsc(BigStorageCageDetails::getSlot)
                    .orderByDesc(BigStorageCageDetails::getId));
            if (CollectionUtils.isNotEmpty(artificialList)) {
                computeOutMoreGlassInfo(artificialList, Boolean.FALSE, mesToPLCAddress);
                computeOutMoreGlassInfo(artificialList, Boolean.FALSE, 1);
                Date endDate = new Date();
                log.info("大理片笼出片任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime());
                return;
@@ -329,7 +400,7 @@
                                .orderBy(Boolean.TRUE, sequenceOrder, GlassInfo::getTemperingFeedSequence));
                        if (CollectionUtils.isNotEmpty(temperingGlassInfos)) {
                            temperingGlassInfoService.saveBatch(temperingGlassInfos);
                            computeOutMoreGlassInfo(temperingGlassInfoList, Boolean.TRUE, mesToPLCAddress);
                            computeOutMoreGlassInfo(temperingGlassInfoList, Boolean.TRUE, 1);
                            Date endDate = new Date();
                            log.info("大理片笼出片任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime());
                            return;
@@ -337,43 +408,66 @@
                    }
                }
            }
        }
        //执行内部调度任务
        List<TemperingLayoutDTO> temperingOccupySlotList = bigStorageCageDetailsService.queryTemperingOccupySlot();
        if (CollectionUtils.isNotEmpty(temperingOccupySlotList)) {
            loop:
            for (TemperingLayoutDTO temperingOccupySlot : temperingOccupySlotList) {
                List<SlotSequenceDTO> slotSequenceList = bigStorageCageDetailsService.queryGlassMaxAndMin(temperingOccupySlot.getEngineerId(), temperingOccupySlot.getTemperingLayoutId());
                for (int i = 0; i < slotSequenceList.size() - 1; i++) {
                    SlotSequenceDTO first = slotSequenceList.get(i);
                    SlotSequenceDTO second = slotSequenceList.get(i + 1);
                    int slotWidth = carWidth - first.getRemainWidth() - glassGap;
                    if (first.getMinSequence() == second.getMaxSequence() + 1
                            && second.getRemainWidth() > slotWidth && slotWidth >= 0) {
                        List<BigStorageCageDetails> list = bigStorageCageDetailsService.list(new LambdaQueryWrapper<BigStorageCageDetails>()
                                .eq(BigStorageCageDetails::getSlot, first.getSlot()).eq(BigStorageCageDetails::getState, Const.GLASS_STATE_IN)
                                .orderBy(Boolean.TRUE, sequenceOrder, BigStorageCageDetails::getTemperingFeedSequence));
                        if (CollectionUtils.isNotEmpty(list)) {
                            List<BigStorageCageOutTask> outTasks = new ArrayList<>();
                            int serialNumber = 1;
                            for (BigStorageCageDetails item : list) {
                                outTasks.add(new BigStorageCageOutTask(item.getGlassId(), first.getSlot(), second.getSlot(),
                                        item.getWidth() * 10, item.getHeight() * 10, 1, serialNumber++, Const.BIG_STORAGE_OUT_NEW, new Date()));
        } else {
            //执行内部调度任务
            List<TemperingLayoutDTO> temperingOccupySlotList = bigStorageCageDetailsService.queryTemperingOccupySlot();
            if (CollectionUtils.isNotEmpty(temperingOccupySlotList)) {
                loop:
                for (TemperingLayoutDTO temperingOccupySlot : temperingOccupySlotList) {
                    List<GlassInfo> glassInfos = glassInfoService.list(
                            new LambdaQueryWrapper<GlassInfo>()
                                    .eq(GlassInfo::getEngineerId, temperingOccupySlot.getEngineerId())
                                    .eq(GlassInfo::getTemperingLayoutId, temperingOccupySlot.getTemperingLayoutId())
                                    .notInSql(GlassInfo::getGlassId, "select glass_id from damage where type=8 and engineer_id='"
                                            + temperingOccupySlot.getEngineerId() + "' and tempering_layout_id = '" + temperingOccupySlot.getTemperingLayoutId() + "'")
                                    .orderBy(Boolean.TRUE, sequenceOrder, GlassInfo::getTemperingFeedSequence)
                    );
                    Map<Integer, List<GlassInfo>> listMap = glassInfos.stream().collect(Collectors.groupingBy(item -> item.getTargetSlot()));
                    for (Map.Entry<Integer, List<GlassInfo>> entry : listMap.entrySet()) {
                        List<GlassInfo> valueList = entry.getValue();
                        List<String> glassIds = valueList.stream().map(GlassInfo::getGlassId).collect(Collectors.toList());
                        List<BigStorageCageDetails> bigStorageCageDetailsList = bigStorageCageDetailsService.list(
                                new LambdaQueryWrapper<BigStorageCageDetails>()
                                        .in(BigStorageCageDetails::getGlassId, glassIds)
                                        .eq(BigStorageCageDetails::getState, Const.GLASS_STATE_IN)
                                        .orderBy(Boolean.TRUE, sequenceOrder, BigStorageCageDetails::getTemperingFeedSequence)
                        );
                        List<BigStorageCageDetails> overSizeGlass = bigStorageCageDetailsList.stream().filter(
                                t -> Math.min(t.getWidth(), t.getHeight()) > 2500
                        ).collect(Collectors.toList());
                        if (CollectionUtils.isEmpty(overSizeGlass)) {
                            //当一格玻璃都到齐时
                            if (bigStorageCageDetailsList.size() == valueList.size()) {
                                long distinctSlotCount = bigStorageCageDetailsList.stream()
                                        .map(BigStorageCageDetails::getSlot)
                                        .distinct()
                                        .count();
                                //当玻璃不在同一格时
                                if (distinctSlotCount > 1) {
                                    BigStorageCageDetails maxSequenceDetail = bigStorageCageDetailsList.stream()
                                            .max(Comparator.comparingInt(BigStorageCageDetails::getTemperingFeedSequence))
                                            .orElse(null);  // 如果没有元素，返回 null
                                    int maxSlot = maxSequenceDetail.getSlot();
                                    int serialNumber = 1;
                                    for (BigStorageCageDetails bigStorageCageDetails : bigStorageCageDetailsList
                                    ) {
                                        if (bigStorageCageDetails.getSlot() != maxSlot) {
                                            bigStorageCageOutTaskService.save(new BigStorageCageOutTask(bigStorageCageDetails.getGlassId(), bigStorageCageDetails.getSlot(), maxSlot,
                                                    bigStorageCageDetails.getWidth() * 10, bigStorageCageDetails.getHeight() * 10, 1, serialNumber++, Const.BIG_STORAGE_OUT_NEW, new Date()));

                                            bigStorageCageDetailsService.update(new LambdaUpdateWrapper<BigStorageCageDetails>().set(BigStorageCageDetails::getState, Const.GLASS_STATE_SCHEDULE_ING)
                                                    .set(BigStorageCageBaseInfo::getSlot, maxSlot).eq(BigStorageCageDetails::getGlassId, bigStorageCageDetails.getGlassId())
                                                    .ne(BigStorageCageDetails::getState, Const.GLASS_STATE_OUT));
                                            //两次更新笼子的剩余尺寸：第一次防止有玻璃继续进调度后的笼子，第二次更新：计算格子的实际尺寸
                                            // 仅更新调度后的格子信息：起始格子完成后更新：防止调度出片过程中有新玻璃进入，
                                        }
                                    }
                                    break loop;
                                }
                            }
                            //新增调度任务
                            bigStorageCageOutTaskService.saveBatch(outTasks);
                            //更新理片笼详情表调度的后的玻璃位置信息：生成任务后先将玻璃格子位置进行调整，玻璃状态改为调度中，新增调度完成任务，处理调度完成后玻璃状态改为100.
                            List<String> glassList = list.stream().map(BigStorageCageDetails::getGlassId).collect(Collectors.toList());
                            bigStorageCageDetailsService.update(new LambdaUpdateWrapper<BigStorageCageDetails>().set(BigStorageCageDetails::getState, Const.GLASS_STATE_SCHEDULE_ING)
                                    .set(BigStorageCageBaseInfo::getSlot, second.getSlot()).in(BigStorageCageDetails::getGlassId, glassList));
                            //两次更新笼子的剩余尺寸：第一次防止有玻璃继续进调度后的笼子，第二次更新：计算格子的实际尺寸
                            // 仅更新调度后的格子信息：起始格子完成后更新：防止调度出片过程中有新玻璃进入，
                            updateSlotRemainBySlots(Arrays.asList(second.getSlot()));
                            break loop;
                        }
                    }
                }
            }
//            //向plc写入确认字
//            int returnData = 0;
//            int count = 1;
@@ -383,10 +477,12 @@
//                returnData = S7object.getinstance().plccontrol.readWord(mesToPLCAddress, 1).get(0);
//                log.info("已向plc第{}次发送出片任务确认，地址为：{},写入的内容为{}", count++, mesToPLCAddress, returnData);
//            }
            Date endDate = new Date();
            log.info("大理片笼出片任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime());
            return;
                Date endDate = new Date();
                log.info("大理片笼出片任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime());
                return;
            }
        }

    }

    @Scheduled(fixedDelay = 300)
@@ -430,7 +526,8 @@
        log.info("1、大理片笼出片完成后更新大理片笼数据任务开始执行时间：{}", startDate);
        //因为大理片笼和出片任务是两个库的数据，所以要分开查找
        List<Object> list = bigStorageCageDetailsService.listObjs(new LambdaQueryWrapper<BigStorageCageDetails>()
                .select(BigStorageCageDetails::getGlassId).eq(BigStorageCageDetails::getState, Const.GLASS_STATE_OUT_ING));
                .select(BigStorageCageDetails::getGlassId)
                .in(BigStorageCageDetails::getState, Const.GLASS_STATE_OUT_ING));
        if (CollectionUtils.isNotEmpty(list)) {
            log.info("2、获取所有正在出片的玻璃信息id:{}", list);
            List<String> glassIds = list.stream().map(String::valueOf).collect(Collectors.toList());
@@ -520,14 +617,17 @@
            bigStorageCageFeedTaskService.remove(new LambdaQueryWrapper<BigStorageCageFeedTask>().in(BigStorageCageFeedTask::getTaskState, Const.GLASS_STATE_DAMAGE_TAKE));
            //理片笼详情表数据状态更新
            bigStorageCageDetailsService.remove(new LambdaQueryWrapper<BigStorageCageDetails>()
                    .eq(BigStorageCageDetails::getState, Const.GLASS_STATE_NEW).in(BigStorageCageDetails::getGlassId, inDamageTaskInfoList.stream().map(BigStorageCageFeedTask::getGlassId).collect(Collectors.toList())));
//                    .eq(BigStorageCageDetails::getState, Const.GLASS_STATE_NEW)
                    .and(e -> e.eq(BigStorageCageDetails::getState, Const.GLASS_STATE_NEW).or()
                            .eq(BigStorageCageDetails::getState, Const.GLASS_STATE_IN))
                    .in(BigStorageCageDetails::getGlassId, inDamageTaskInfoList.stream().map(BigStorageCageFeedTask::getGlassId).collect(Collectors.toList())));
            //将破损信息新增入破损表
            List<Integer> slotList = new ArrayList<>();
            for (BigStorageCageFeedTask bigStorageCageFeedTask : inDamageTaskInfoList) {
                Damage damage = new Damage();
                damage.setGlassId(bigStorageCageFeedTask.getGlassId());
                damage.setLine(bigStorageCageFeedTask.getLine());
                damage.setWorkingProcedure("磨边");
                damage.setWorkingProcedure("钢化");
                damage.setRemark("进笼前卧转立");
                damage.setStatus(1);
                damage.setType(bigStorageCageFeedTask.getTaskState());
@@ -581,23 +681,36 @@
        String d04ToMES = plcParameterObject.getPlcParameter("D04ToMES").getValue();
        String mesD01Address = plcParameterObject.getPlcParameter("MESToD01").getAddress();
        String mesD04Address = plcParameterObject.getPlcParameter("MESToD04").getAddress();
        String d03ToMES = plcParameterObject.getPlcParameter("D03ToMES").getValue();
        String d05ToMES = plcParameterObject.getPlcParameter("D05ToMES").getValue();
//        String d03ToMES = plcParameterObject.getPlcParameter("D03ToMES").getValue();
//        String d05ToMES = plcParameterObject.getPlcParameter("D05ToMES").getValue();
        String d03ToMES = plcParameterObject.getPlcParameter("D03Request").getValue();
        String d05ToMES = plcParameterObject.getPlcParameter("D05Request").getValue();
        String mesD03Address = plcParameterObject.getPlcParameter("MESToD03").getAddress();
        String mesD05Address = plcParameterObject.getPlcParameter("MESToD05").getAddress();
        String carRequest = plcParameterObject.getPlcParameter("CarRequest").getValue();
        String carResponse = plcParameterObject.getPlcParameter("CarResponse").getAddress();
        if (!REQUEST_WORD.equals(d01ToMES)) {
            log.info("地址：{}写入0", mesD01Address);
            S7object.getinstance().plccontrol.writeWord(mesD01Address, 0);
        }
        if (!REQUEST_WORD.equals(d04ToMES)) {
            log.info("地址：{}写入0", mesD04Address);
            S7object.getinstance().plccontrol.writeWord(mesD04Address, 0);
        }
        if (!REQUEST_WORD.equals(d03ToMES)) {
            log.info("地址：{}写入0", mesD03Address);
            S7object.getinstance().plccontrol.writeWord(mesD03Address, 0);
        }
        if (!REQUEST_WORD.equals(d05ToMES)) {
            log.info("地址：{}写入0", mesD05Address);
            S7object.getinstance().plccontrol.writeWord(mesD05Address, 0);
        }
        if (!REQUEST_WORD.equals(carRequest)) {
            log.info("地址：{}写入0", carResponse);
            S7object.getinstance().plccontrol.writeWord(carResponse, 0);
        }
    }


    /**
     * 进片状态修改
@@ -605,58 +718,73 @@
    @Scheduled(fixedDelay = 300)
    public void feedStatusUpdate() {
        PlcParameterObject plcParameterObject = S7object.getinstance().PlcMesObject;
        String mesD03Address = plcParameterObject.getPlcParameter("MESToD03").getAddress();
        String mesD05Address = plcParameterObject.getPlcParameter("MESToD05").getAddress();
        List<String> glassIds1 = new ArrayList<>();
        List<String> glassIds2 = new ArrayList<>();
//        for (int i = 1; i <= 6; i++) {
//            String line1GlassId = plcParameterObject.getPlcParameter("D03ID" + i).getValue();
//            if (StringUtils.isNotEmpty(line1GlassId)) {
//                glassIds1.add(line1GlassId);
//            }
//            String line2GlassId = plcParameterObject.getPlcParameter("D05ID" + i).getValue();
//            if (StringUtils.isNotEmpty(line2GlassId)) {
//                glassIds1.add(line2GlassId);
//            }
//        }
        List<String> glassIdsCar = new ArrayList<>();
        for (int i = 1; i <= 6; i++) {
            String line1GlassId = plcParameterObject.getPlcParameter("D03ID" + i).getValue();
            if (StringUtils.isNotEmpty(line1GlassId)) {
                glassIds1.add(line1GlassId);
            }
            String line2GlassId = plcParameterObject.getPlcParameter("D05ID" + i).getValue();
            if (StringUtils.isNotEmpty(line2GlassId)) {
                glassIds2.add(line2GlassId);
            }
            String carGlassId = plcParameterObject.getPlcParameter("E01ID" + i).getValue();
            if (StringUtils.isNotEmpty(carGlassId)) {
                glassIdsCar.add(carGlassId);
            }
        }
        List<BigStorageCageFeedTask> bigStorageCageFeedTasks1 = bigStorageCageFeedTaskService.list(
                new LambdaQueryWrapper<BigStorageCageFeedTask>()
                        .eq(BigStorageCageFeedTask::getTaskState, 1)
                        .eq(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_NEW)
                        .eq(BigStorageCageFeedTask::getLine, Const.A09_OUT_TARGET_POSITION)
        );
        List<BigStorageCageFeedTask> bigStorageCageFeedTasks2 = bigStorageCageFeedTaskService.list(
                new LambdaQueryWrapper<BigStorageCageFeedTask>()
                        .eq(BigStorageCageFeedTask::getTaskState, 1)
                        .eq(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_NEW)
                        .eq(BigStorageCageFeedTask::getLine, Const.A10_OUT_TARGET_POSITION)
        );
        if (CollectionUtils.isNotEmpty(bigStorageCageFeedTasks1)&& glassIds1 != null) {
        if (CollectionUtils.isNotEmpty(bigStorageCageFeedTasks1) && CollectionUtils.isNotEmpty(glassIds1)) {
            List<String> matchingIds1 = bigStorageCageFeedTasks1.stream()
                    .map(BigStorageCageFeedTask::getGlassId)
                    .filter(glassIds1::contains)
                    .distinct()
                    .collect(Collectors.toList());
            bigStorageCageFeedTaskService.update(
                    new LambdaUpdateWrapper<BigStorageCageFeedTask>()
                            .in(BigStorageCageFeedTask::getGlassId, matchingIds1)
                            .lt(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_SLOT)
                            .set(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_UP)
            );
            log.info("D3id{},匹配id:{}", glassIds1, matchingIds1);
            if (CollectionUtils.isNotEmpty(matchingIds1)) {
                bigStorageCageFeedTaskService.update(
                        new LambdaUpdateWrapper<BigStorageCageFeedTask>()
                                .in(BigStorageCageFeedTask::getGlassId, matchingIds1)
                                .lt(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_SLOT)
                                .set(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_UP)
                );
            }
        }
        if (CollectionUtils.isNotEmpty(bigStorageCageFeedTasks2)&& glassIds2 != null) {
        if (CollectionUtils.isNotEmpty(bigStorageCageFeedTasks2) && CollectionUtils.isNotEmpty(glassIds2)) {
            List<String> matchingIds2 = bigStorageCageFeedTasks2.stream()
                    .map(BigStorageCageFeedTask::getGlassId)
                    .filter(glassIds2::contains)
                    .distinct()
                    .collect(Collectors.toList());
            bigStorageCageFeedTaskService.update(
                    new LambdaUpdateWrapper<BigStorageCageFeedTask>()
                            .in(BigStorageCageFeedTask::getGlassId, matchingIds2)
                            .lt(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_SLOT)
                            .set(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_UP)
            );
            log.info("D5id{},匹配id:{}", glassIds2, matchingIds2);
            if (CollectionUtils.isNotEmpty(matchingIds2)) {
                bigStorageCageFeedTaskService.update(
                        new LambdaUpdateWrapper<BigStorageCageFeedTask>()
                                .in(BigStorageCageFeedTask::getGlassId, matchingIds2)
                                .lt(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_SLOT)
                                .set(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_UP)
                );
            }
        }
        if (CollectionUtils.isEmpty(glassIds1)) {
            S7object.getinstance().plccontrol.writeWord(mesD03Address, 0);
            log.info("{}线修改玻璃{}状态为3", Const.A09_OUT_TARGET_POSITION, glassIds1);
            bigStorageCageFeedTaskService.update(
                    new LambdaUpdateWrapper<BigStorageCageFeedTask>()
                            .eq(BigStorageCageFeedTask::getLine,Const.A09_OUT_TARGET_POSITION)
                            .eq(BigStorageCageFeedTask::getLine, Const.A09_OUT_TARGET_POSITION)
                            .eq(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_UP)
                            .gt(BigStorageCageFeedTask::getTargetSlot, 0)
                            .lt(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_SLOT)
@@ -664,21 +792,69 @@
            );
        }
        if (CollectionUtils.isEmpty(glassIds2)) {
            S7object.getinstance().plccontrol.writeWord(mesD05Address, 0);
            log.info("{}线修改玻璃{}状态为3", Const.A10_OUT_TARGET_POSITION, glassIds2);
            bigStorageCageFeedTaskService.update(
                    new LambdaUpdateWrapper<BigStorageCageFeedTask>()
                            .eq(BigStorageCageFeedTask::getLine,Const.A10_OUT_TARGET_POSITION)
                            .eq(BigStorageCageFeedTask::getLine, Const.A10_OUT_TARGET_POSITION)
                            .eq(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_UP)
                            .gt(BigStorageCageFeedTask::getTargetSlot, 0)
                            .lt(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_SLOT)
                            .set(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_CAR)
            );
        }
        String carRequest = plcParameterObject.getPlcParameter("CarRequest").getValue();
        log.info("大车当前玻璃id{}", glassIdsCar);
        log.info("卧转立1玻璃id{}", glassIds1);
        log.info("卧转立2玻璃id{}", glassIds2);
        if (CollectionUtils.isNotEmpty(glassIdsCar) && REQUEST_WORD.equals(carRequest)) {
            List<BigStorageCageFeedTask> bigStorageCageFeedTasks = bigStorageCageFeedTaskService.list(
                    new LambdaQueryWrapper<BigStorageCageFeedTask>()
                            .in(BigStorageCageFeedTask::getGlassId, glassIdsCar)
                            .eq(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_UP)
                            .eq(BigStorageCageFeedTask::getTargetSlot, 0)
            );
            if (CollectionUtils.isNotEmpty(bigStorageCageFeedTasks)) {
                log.info("计算目标格子发送任务{}", bigStorageCageFeedTasks);
                computeTargetByLineCar(bigStorageCageFeedTasks.get(0).getLine(), glassIdsCar);
            } else {
                log.info("再次发送进片任务{}", bigStorageCageFeedTasks);
                List<BigStorageCageFeedTask> bigStorageCageFeedTaskList = bigStorageCageFeedTaskService.list(
                        new LambdaQueryWrapper<BigStorageCageFeedTask>()
                                .in(BigStorageCageFeedTask::getGlassId, glassIdsCar)
                                .eq(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_CAR)
                                .gt(BigStorageCageFeedTask::getTargetSlot, 0)
                );
                if (CollectionUtils.isNotEmpty(bigStorageCageFeedTaskList)) {
                    sendTaskListToPLCCar(bigStorageCageFeedTaskList);
                }
            }
        }


    }

    /**
     * 按照玻璃id判断玻璃状态及卧转立是否可直接启动
     */
    public Boolean judgeGlassTypeStatus(String glassId, Integer line, String mesAddress) {
//        预排格子
//        computeSlot(glassId);
        //判断此玻璃是在笼内或已生成进片任务
        BigStorageCageFeedTask bigStorageCageFeedTask = bigStorageCageFeedTaskService.getOne(
                new LambdaQueryWrapper<BigStorageCageFeedTask>()
                        .lt(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_SLOT)
                        .eq(BigStorageCageFeedTask::getGlassId, glassId)
        );
        BigStorageCageDetails bigStorageCageDetails = bigStorageCageDetailsService.getOne(
                new LambdaQueryWrapper<BigStorageCageDetails>()
                        .eq(BigStorageCageDetails::getGlassId, glassId)
                        .eq(BigStorageCageDetails::getState, Const.GLASS_STATE_IN)
        );
        if (bigStorageCageFeedTask != null || bigStorageCageDetails != null) {
            log.info("此玻璃存任务或已在笼内");
            return Boolean.TRUE;
        }
        //1、获取任务表中相邻玻璃
        List<EdgGlassTaskInfo> edgGlassTaskInfoList;
        edgGlassTaskInfoList = edgGlassTaskInfoService.list(new LambdaQueryWrapper<EdgGlassTaskInfo>()
@@ -698,8 +874,8 @@
                );
                EdgGlassTaskInfo edgGlassTaskInfo = new EdgGlassTaskInfo();
                BeanUtils.copyProperties(glassInfo, edgGlassTaskInfo);
                edgGlassTaskInfo.setWidth((int) glassInfo.getWidth());
                edgGlassTaskInfo.setHeight((int) glassInfo.getHeight());
                edgGlassTaskInfo.setWidth((int) glassInfo.getWidth() * 10);
                edgGlassTaskInfo.setHeight((int) glassInfo.getHeight() * 10);
                edgGlassTaskInfoList.add(edgGlassTaskInfo);
                log.info("在玻璃信息表中获取玻璃信息{}", edgGlassTaskInfoList);
            }
@@ -782,6 +958,37 @@
        return flag;
    }

    public void computeSlot(String glassId) {
        GlassInfo glassInfo = glassInfoService.getOne(
                new LambdaQueryWrapper<GlassInfo>()
                        .eq(GlassInfo::getGlassId, glassId)
        );
        if (glassInfo.getTargetSlot() == null) {
            List<GlassInfo> glassInfos = glassInfoService.list(
                    new LambdaQueryWrapper<GlassInfo>()
                            .eq(GlassInfo::getEngineerId, glassInfo.getEngineerId())
                            .eq(GlassInfo::getTemperingLayoutId, glassInfo.getTemperingLayoutId())
                            .orderBy(Boolean.TRUE, sequenceOrder, GlassInfo::getTemperingFeedSequence)
            );
            List<BigStorageCageDetails> glassInfoLists = new ArrayList<>();
            glassInfos.forEach(item -> {
                BigStorageCageDetails details = new BigStorageCageDetails();
                BeanUtils.copyProperties(item, details);
                details.setSlot(1);
                glassInfoLists.add(details);
            });
            computeOutMoreGlassInfo(glassInfoLists, Boolean.TRUE, 2);
            for (BigStorageCageOutTask bigStorageCageOutTask : allTask
            ) {
                glassInfoService.update(
                        new LambdaUpdateWrapper<GlassInfo>()
                                .eq(GlassInfo::getGlassId, bigStorageCageOutTask.getGlassId())
                                .set(GlassInfo::getTargetSlot, bigStorageCageOutTask.getTrainNumber())
                );
            }
        }
    }

    /**
     * 添加任务信息
     */
@@ -794,6 +1001,7 @@
        bigStorageCageFeedTask.setWidth(width);
        bigStorageCageFeedTask.setHeight(height);
        bigStorageCageFeedTask.setCreateTime(new Date());
        bigStorageCageFeedTask.setTargetSlot(0);
        //删除理片笼表拿走/破损数据数据
        damageService.deleteByGlassId(glassId);
        Damage damage = new Damage();
@@ -830,10 +1038,20 @@
     * 计算任务表进片线路的目标格子，并启动任务
     */
    public boolean computeTargetByLine(Integer line) {
        sendTaskListToPLC(new ArrayList<>(), line);
        return true;
    }

    /**
     * 计算任务表进片线路的目标格子，并启动任务
     */
    public boolean computeTargetByLineCar(Integer line, List<String> carGlassId) {
        //1、获取任务表中的所有玻璃（指定线路且已经进卧转立完成）
        List<BigStorageCageFeedTask> taskList = bigStorageCageFeedTaskService.list(new LambdaQueryWrapper<BigStorageCageFeedTask>()
                .eq(BigStorageCageFeedTask::getLine, line)
                .and(e -> e.isNull(BigStorageCageFeedTask::getTargetSlot).or().eq(BigStorageCageFeedTask::getTargetSlot, Const.OUT_TARGET_POSITION_ZERO))
                .in(BigStorageCageFeedTask::getGlassId, carGlassId)
                .and(e -> e.isNull(BigStorageCageFeedTask::getTargetSlot).or()
                        .eq(BigStorageCageFeedTask::getTargetSlot, Const.OUT_TARGET_POSITION_ZERO))
                .in(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_UP_ALL)
                .orderByAsc(BigStorageCageFeedTask::getId));
        //2、去笼子内查找是否可以继续存放的笼子
@@ -854,9 +1072,22 @@
        Map<String, GlassInfo> glassInfoMap = glassInfos.stream()
                .collect(Collectors.toMap(GlassInfo::getGlassId, p -> p));
        for (BigStorageCageFeedTask e : taskList) {
            GlassInfo info = glassInfoMap.get(e.getGlassId());
            //替换玻璃id
            queryAndChangeGlass(e.getGlassId());
            GlassInfo info = glassInfoService.getOne(
                    new LambdaQueryWrapper<GlassInfo>()
                            .eq(GlassInfo::getGlassId, e.getGlassId())
            );
//            GlassInfo info = glassInfoMap.get(e.getGlassId());
            if (info == null) {
                continue;
            }
            if (info.getTargetSlot() == null) {
                computeSlot(info.getGlassId());
                info = glassInfoService.getOne(
                        new LambdaQueryWrapper<GlassInfo>()
                                .eq(GlassInfo::getGlassId, info.getGlassId())
                );
            }
            BigStorageCageDetails cageDetails = new BigStorageCageDetails();
            BeanUtils.copyProperties(info, cageDetails);
@@ -877,8 +1108,26 @@
            bigStorageCageDetailsService.save(cageDetails);

        }
        sendTaskListToPLC(taskList, line);
        sendTaskListToPLCCar(taskList);
        return Boolean.TRUE;
    }

    private void sendTaskListToPLCCar(List<BigStorageCageFeedTask> taskList) {
        S7control s7control = S7object.getinstance().plccontrol;
        PlcParameterObject plcMesObject = S7object.getinstance().PlcMesObject;
        List<String> returnData = new ArrayList<>();
        for (int i = 1; i <= taskList.size(); i++) {
            s7control.writeWord(plcMesObject.getPlcParameter("StartAddToImport" + i).getAddress(), taskList.get(i - 1).getLine());
            s7control.writeWord(plcMesObject.getPlcParameter("TargetAddToImport" + i).getAddress(), taskList.get(i - 1).getTargetSlot());
            returnData.add(taskList.get(i - 1).getGlassId());
            log.info("向plc发送第{}片玻璃已完成,起始位置是{}，目标位置是", i, taskList.get(i - 1).getLine(), taskList.get(i - 1).getTargetSlot());
        }
        String carRequest = plcMesObject.getPlcParameter("CarRequest").getValue();
        String CarResponse = plcMesObject.getPlcParameter("CarResponse").getAddress();
        while (REQUEST_WORD.equals(carRequest)) {
            s7control.writeWord(CarResponse, 1);
            carRequest = plcMesObject.getPlcParameter("CarRequest").getValue();
        }
    }

    private void sendTaskListToPLC(List<BigStorageCageFeedTask> taskList, Integer line) {
@@ -888,23 +1137,54 @@
        String mesD03Address = plcMesObject.getPlcParameter("MESToD03").getAddress();
        String mesD05Address = plcMesObject.getPlcParameter("MESToD05").getAddress();
        String outLine = line.equals(Const.A09_OUT_TARGET_POSITION) ? mesD03Address : mesD05Address;
        for (int i = 1; i <= taskList.size(); i++) {
            s7control.writeWord(plcMesObject.getPlcParameter("StartAddToImport" + i).getAddress(), taskList.get(i - 1).getLine());
            s7control.writeWord(plcMesObject.getPlcParameter("TargetAddToImport" + i).getAddress(), taskList.get(i - 1).getTargetSlot());
            log.info("向plc发送第{}片玻璃已完成,起始位置是{}，目标位置是", i, taskList.get(i - 1).getLine(), taskList.get(i - 1).getTargetSlot());
        }
        int returnData = 1;
        List<String> returnData = new ArrayList<>();
        returnData.add("glassid");
//        for (int i = 1; i <= taskList.size(); i++) {
//            s7control.writeWord(plcMesObject.getPlcParameter("StartAddToImport" + i).getAddress(), taskList.get(i - 1).getLine());
//            s7control.writeWord(plcMesObject.getPlcParameter("TargetAddToImport" + i).getAddress(), taskList.get(i - 1).getTargetSlot());
//            returnData.add(taskList.get(i - 1).getGlassId());
//            log.info("向plc发送第{}片玻璃已完成,起始位置是{}，目标位置是", i, taskList.get(i - 1).getLine(), taskList.get(i - 1).getTargetSlot());
//        }
//        int returnData = 1;
        int count = 1;
        while (returnData != 0) {


        while (CollectionUtils.isNotEmpty(returnData)) {
            List<String> glassIds1 = new ArrayList<>();
            List<String> glassIds2 = new ArrayList<>();
            s7control.writeWord(outLine, 2);
            for (int i = 1; i <= 6; i++) {
                String line1GlassId = plcMesObject.getPlcParameter("D03ID" + i).getValue();
                if (StringUtils.isNotEmpty(line1GlassId)) {
                    glassIds1.add(line1GlassId);
                }
                String line2GlassId = plcMesObject.getPlcParameter("D05ID" + i).getValue();
                if (StringUtils.isNotEmpty(line2GlassId)) {
                    glassIds2.add(line2GlassId);
                }
            }
            if (line.equals(Const.A09_OUT_TARGET_POSITION)) {
                returnData = Integer.parseInt(plcMesObject.getPlcParameter("D03ToMES").getValue());
//                returnData = Integer.parseInt(plcMesObject.getPlcParameter("D03ToMES").getValue());
                returnData = glassIds1;
            } else {
                returnData = Integer.parseInt(plcMesObject.getPlcParameter("D05ToMES").getValue());
//                returnData = Integer.parseInt(plcMesObject.getPlcParameter("D05ToMES").getValue());
                returnData = glassIds2;
            }
//            returnData = s7control.readWord(outLine, 1).get(0);
            log.info("已向plc第{}次发送进片任务确认，地址为：{},写入的内容为{}", count++, outLine, 2);
            log.info("已向plc第{}次发送进片卧转立，地址为：{},写入的内容为{},读到的请求为{}", count++, outLine, 2, returnData);
        }
//        while (returnData != 0) {
//            s7control.writeWord(outLine, 2);
//            if (line.equals(Const.A09_OUT_TARGET_POSITION)) {
////                returnData = Integer.parseInt(plcMesObject.getPlcParameter("D03ToMES").getValue());
//                returnData = s7control.readWord(plcMesObject.getPlcParameter("D03Request").getAddress(), 1).get(0);
//            } else {
////                returnData = Integer.parseInt(plcMesObject.getPlcParameter("D05ToMES").getValue());
//                returnData = s7control.readWord(plcMesObject.getPlcParameter("D05Request").getAddress(), 1).get(0);
//            }
////            returnData = s7control.readWord(outLine, 1).get(0);
//            log.info("已向plc第{}次发送进片任务确认，地址为：{},写入的内容为{},读到的请求为{}", count++, outLine, 2,returnData);
//        }
    }

    /**
@@ -965,11 +1245,11 @@
     *
     * @param list
     * @param isTempering
     * @param mesToPLCAddress
     * @param isTask
     * @param <T>
     * @return
     */
    public <T extends BigStorageCageBaseInfo> Boolean computeOutMoreGlassInfo(List<T> list, Boolean isTempering, String mesToPLCAddress) {
    public <T extends BigStorageCageBaseInfo> Boolean computeOutMoreGlassInfo(List<T> list, Boolean isTempering, Integer isTask) {
        //任务数据  获取车子存放玻璃最大数量  玻璃间隔
        List<BigStorageCageOutTask> bigStorageCageOutTaskList = new ArrayList<>();
        //打车剩余尺寸
@@ -977,41 +1257,72 @@
        int trainNumber = 1;
        int serialNumber = 1;
        int maxX = 0;
        int slot = 0;
        for (T e : list) {
            int maxLength = Math.max((int) e.getWidth(), (int) e.getHeight());
            if (serialNumber > outCarMaxSize || maxLength > remainWidth) {
                remainWidth = carWidth;
                trainNumber = trainNumber + 1;
                serialNumber = 1;
                maxX = 0;
            }
            remainWidth = remainWidth - maxLength - glassGap;
            if (isTempering) {
                int minLength = Math.min((int) e.getWidth(), (int) e.getHeight());
                if (maxX + minLength <= xMaxSize) {
                if (maxX + minLength <= xMaxSize && serialNumber <= outCarMaxSize && remainWidth > maxLength) {
                    if (slot != e.getSlot() && slot != 0) {
                        int finalMaxX = maxX;
                        int finalSerialNumber = serialNumber;
                        int finalRemainWidth = remainWidth;
                        List<T> lists = list.stream().filter(t -> t.getSlot() == (int) e.getSlot()).collect(Collectors.toList());
                        for (T x : lists) {
                            int finalMinLength = Math.min((int) x.getWidth(), (int) x.getHeight());
                            int finalMaxLength = Math.max((int) e.getWidth(), (int) e.getHeight());
                            if (finalMaxX + finalMinLength > xMaxSize || finalSerialNumber > outCarMaxSize || finalMaxLength > finalRemainWidth) {
                                remainWidth = carWidth;
                                trainNumber = trainNumber + 1;
                                serialNumber = 1;
                                maxX = 0;
                                break;
                            } else {
                                finalMaxX = Math.max(maxX, x.getXCoordinate());
                                finalRemainWidth = finalRemainWidth - finalMaxLength - glassGap;
                                finalSerialNumber++;
                            }
                        }
                    }
                    bigStorageCageOutTaskList.add(new BigStorageCageOutTask(e.getGlassId(), e.getSlot(), Const.TEMPERING_OUT_TARGET_POSITION,
                            e.getWidth() * 10, e.getHeight() * 10, trainNumber, serialNumber++, 1, new Date()));
                    remainWidth = remainWidth - maxLength - glassGap;
                    maxX = Math.max(maxX, e.getXCoordinate());
                    slot = e.getSlot();
                } else {
                    remainWidth = carWidth - maxLength - glassGap;
                    trainNumber = trainNumber + 1;
                    serialNumber = 1;
                    maxX = e.getXCoordinate();
                    slot = e.getSlot();
                    bigStorageCageOutTaskList.add(new BigStorageCageOutTask(e.getGlassId(), e.getSlot(), Const.TEMPERING_OUT_TARGET_POSITION,
                            e.getWidth() * 10, e.getHeight(), trainNumber, serialNumber++, 1, new Date()));
                            e.getWidth() * 10, e.getHeight() * 10, trainNumber, serialNumber++, 1, new Date()));
                }
            } else {
                bigStorageCageOutTaskList.add(new BigStorageCageOutTask(e.getGlassId(), e.getSlot(), Const.ARTIFICIAL_OUT_TARGET_POSITION,
                        e.getWidth() * 10, e.getHeight(), trainNumber, serialNumber++, 1, new Date()));
                if(serialNumber <= outCarMaxSize && remainWidth > maxLength){
                    remainWidth = remainWidth - maxLength - glassGap;
                    bigStorageCageOutTaskList.add(new BigStorageCageOutTask(e.getGlassId(), e.getSlot(), Const.ARTIFICIAL_OUT_TARGET_POSITION,
                            e.getWidth() * 10, e.getHeight() * 10, trainNumber, serialNumber++, 1, new Date()));
                }else{
                    remainWidth = carWidth - maxLength - glassGap;
                    trainNumber = trainNumber + 1;
                    serialNumber = 1;
                    bigStorageCageOutTaskList.add(new BigStorageCageOutTask(e.getGlassId(), e.getSlot(), Const.ARTIFICIAL_OUT_TARGET_POSITION,
                            e.getWidth() * 10, e.getHeight() * 10, trainNumber, serialNumber++, 1, new Date()));
                }

            }
        }
        if (isTask == 2) {
            allTask = bigStorageCageOutTaskList;
            return Boolean.FALSE;
        } else if (isTask == 3) {
            notAllTask = bigStorageCageOutTaskList;
            return Boolean.FALSE;
        }
        Assert.isFalse(CollectionUtils.isEmpty(bigStorageCageOutTaskList), "未获取出片数据，结束出片任务");
        log.info("获取出片任务数据{}条，执行保存", bigStorageCageOutTaskList.size());
        for (BigStorageCageOutTask bigStorageCageOutTask : bigStorageCageOutTaskList
        ) {
            bigStorageCageOutTaskService.save(bigStorageCageOutTask);
        }
//        bigStorageCageOutTaskService.saveBatch(bigStorageCageOutTaskList);
        bigStorageCageOutTaskService.saveBatch(bigStorageCageOutTaskList);
        List<String> glassIds = bigStorageCageOutTaskList.stream().map(BigStorageCageOutTask::getGlassId).collect(Collectors.toList());
        log.info("将出片玻璃{}玻璃状态改为已出片", glassIds);
        bigStorageCageDetailsService.update(new LambdaUpdateWrapper<BigStorageCageDetails>()
@@ -1045,7 +1356,7 @@
            });
        }
        //过滤不存在玻璃的格子 将宽度重置为原始宽度5000
        Set<Integer> remainSlotList = slotRemainMap.keySet();
        List<Integer> remainSlotList = new ArrayList<>(slotRemainMap.keySet());
        slotList.removeAll(remainSlotList);
        if (CollectionUtils.isNotEmpty(slotList)) {
            bigStorageCageService.update(new LambdaUpdateWrapper<BigStorageCage>().set(BigStorageCage::getRemainWidth, slotWidth)
@@ -1059,9 +1370,52 @@
        if (sitToUpRemainWidth.getGlassCount() == 0) {
            return Boolean.FALSE;
        }
        List<Integer> lineList = bigStorageCageFeedTaskService.querySitToUpGlass();
        if (CollectionUtils.isNotEmpty(lineList)) {
            Integer lineFirst = lineList.get(0);
            if (line == lineFirst) {
                return Boolean.TRUE;
            } else {
                return Boolean.FALSE;
            }
        } else {
            return Boolean.FALSE;
        }

        //获取玻璃信息
//        GlassInfo glassInfo = glassInfoService.getOne(new LambdaQueryWrapper<GlassInfo>().eq(GlassInfo::getGlassId, glassId));
//        return sitToUpRemainWidth.getWidth() < Math.max(glassInfo.getWidth(), glassInfo.getHeight());
    }

    public String queryAndChangeGlass(String glassId) {
        GlassInfo glassInfo = glassInfoService.getOne(new LambdaQueryWrapper<GlassInfo>().eq(GlassInfo::getGlassId, glassId));
        return sitToUpRemainWidth.getWidth() < Math.max(glassInfo.getWidth(), glassInfo.getHeight());
        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())
                .eq(GlassInfo::getMarkIcon, glassInfo.getMarkIcon())
                .notInSql(GlassInfo::getGlassId, "select distinct glass_id from big_storage_cage_details " +
                        "where engineer_id = '" + glassInfo.getEngineerId() + "' and width = " + glassInfo.getWidth() + " and height = " + glassInfo.getHeight())
                .orderByAsc(GlassInfo::getTemperingLayoutId)
                .orderBy(Boolean.TRUE, sequenceOrder, GlassInfo::getTemperingFeedSequence)
                .last("Limit 1");
        GlassInfo swapGlassInfo = glassInfoService.getOne(queryWrapper);
        if (swapGlassInfo != null && !glassInfo.getGlassId().equals(swapGlassInfo.getGlassId())) {
            String swapGlassId = swapGlassInfo.getGlassId();
            log.info("将玻璃{}和玻璃{}，信息互换,进玻璃 {}", glassInfo, swapGlassInfo, swapGlassInfo);
            swapGlassInfo.setGlassId(glassId);
            glassInfo.setGlassId(swapGlassId);
            glassInfoService.updateById(swapGlassInfo);
            glassInfoService.updateById(glassInfo);
            return swapGlassId;
        }
        return "";
    }

}