1、大理片笼：选择工程号没有是否旋转字段的值 2、将钢化小片表中电气需要的字段改为int（宽高厚、旋转角度）

zhoushihao

2024-07-21 dbdf9238c808566a0cef6cd3858f6f3ee2d7bacd

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

@@ -2,36 +2,43 @@

import cn.hutool.core.lang.Assert;
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.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.github.yulichang.toolkit.JoinWrappers;
import com.github.yulichang.wrapper.MPJLambdaWrapper;
import com.mes.base.entity.BigStorageCageBaseInfo;
import com.mes.bigstorage.entity.BigStorageCage;
import com.mes.bigstorage.entity.BigStorageCageDetails;
import com.mes.bigstorage.entity.BigStorageDTO;
import com.mes.bigstorage.entity.dto.SlotSequenceDTO;
import com.mes.bigstorage.entity.dto.TemperingLayoutDTO;
import com.mes.bigstorage.service.BigStorageCageDetailsService;
import com.mes.bigstorage.service.BigStorageCageService;
import com.mes.bigstoragetask.entity.BigStorageCageFeedTask;
import com.mes.bigstoragetask.entity.BigStorageCageOutTask;
import com.mes.bigstoragetask.service.BigStorageCageFeedTaskService;
import com.mes.bigstoragetask.service.BigStorageCageOutTaskService;
import com.mes.common.S7object;
import com.mes.common.config.Const;
import com.mes.damage.entity.Damage;
import com.mes.damage.service.DamageService;
import com.mes.device.PlcParameterObject;
import com.mes.edgglasstask.entity.EdgGlassTaskInfo;
import com.mes.edgglasstask.service.EdgGlassTaskInfoService;
import com.mes.glassinfo.entity.GlassInfo;
import com.mes.glassinfo.service.GlassInfoService;
import com.mes.temperingglass.entity.TemperingGlassInfo;
import com.mes.temperingglass.service.TemperingGlassInfoService;
import com.mes.tools.S7control;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang.StringUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.concurrent.atomic.AtomicReference;
import java.util.*;
import java.util.stream.Collectors;

/**
@@ -55,212 +62,362 @@
    private EdgGlassTaskInfoService edgGlassTaskInfoService;
    @Resource
    private TemperingGlassInfoService temperingGlassInfoService;
    @Resource
    private DamageService damageService;

    private static final String REQUEST_WORD = "1";

    @Value("${mes.sequence.order}")
    private boolean sequenceOrder;

    public static boolean bigStorageCageFullAlarm = false;
    @Value("${mes.carWidth}")
    private Integer carWidth;

    private int line1Time = 0;
    private int line2Time = 0;
    @Value("${mes.slotWidth}")
    private Integer slotWidth;

    /**
     * fixedRate : 上一个调用开始后再次调用的延时（不用等待上一次调用完成）
     * fixedDelay : 上一个调用结束后再次调用的延时
     */
//    @Scheduled(fixedDelay = 5000)
//    public void plcStorageCageTask() throws InterruptedException {
//
//        PlcParameterObject plcParameterObject = S7object.getinstance().PlcMesObject;
//        try {
//
//            String plcFeedGlassid = "";
//            String plcFeedReqLine = "0";
//            if ("1".equals(plcParameterObject.getPlcParameter("D01Request").getValue())) {
//                plcFeedReqLine = "1";
//                plcFeedGlassid = plcParameterObject.getPlcParameter("D01ID1").getValue();
//            }
//            if ("1".equals(plcParameterObject.getPlcParameter("D04Request").getValue())) {
//                plcFeedReqLine = "2";
//                plcFeedGlassid = plcParameterObject.getPlcParameter("D04ID1").getValue();
//            }
//            line1Time += 1;
//            line2Time += 1;
//
//            if (!("0".equals(plcFeedReqLine))) {
//                log.info("1、Plc进片请求时");
//                BigStorageCageDetails bigStorageCageDetails = new BigStorageCageDetails();
//                GlassInfo glassInfo = glassInfoService.getById(plcFeedGlassid);
//                log.info("2、根据玻璃id获取玻璃信息" + glassInfo);
//                if (bigStorageCageDetailsService.selectGetBoard(plcFeedReqLine) >= 0) {
//                    BigStorageCageDetails slotInfo = bigStorageCageService.feedGlass(glassInfo, bigStorageCageDetails);
//                    if (slotInfo != null) {
//                        int taskType = edgGlassTaskInfoService.judgeTasktype(plcFeedReqLine);
//                        log.info("3、查询任务表判断当前任务类型为上车等到还是上车启动" + taskType);
//                        bigStorageCageFeedTaskService.addFeedTask(slotInfo, Integer.parseInt(plcFeedReqLine), taskType);
//                        log.info("4、添加任务到任务表");
//                        bigStorageCageFullAlarm = false;
//                    } else {
//                        bigStorageCageFullAlarm = true;
//                    }
//                } else {
//                    log.info("当前玻璃宽度不够上车" + glassInfo);
//                    if (!("1".equals(plcFeedReqLine))) {
//                        S7object.getinstance().plccontrol.writetime(plcParameterObject.getPlcParameter("D02Go").getAddress(), 1);
//                    } else {
//                        S7object.getinstance().plccontrol.writetime(plcParameterObject.getPlcParameter("D05Go").getAddress(), 1);
//                    }
//                }
//            } else {
//                List<BigStorageCageFeedTask> bigStorageCageFeedTaskList = bigStorageCageFeedTaskService.querybigStorageCageFeedTask(1);
//                log.info("5、查询任务表是否有已经完成的进片任务" + bigStorageCageFeedTaskList.size());
//                for (BigStorageCageFeedTask bigStorageCageFeedTask : bigStorageCageFeedTaskList
//                ) {
//                    BigStorageCageDetails bigStorageCageDetails = new BigStorageCageDetails();
//                    bigStorageCageDetails.setId(bigStorageCageFeedTask.getId());
//                    bigStorageCageDetails.setState(1);
//                    bigStorageCageDetailsService.updateById(bigStorageCageDetails);
//                    log.info("6、修改理片笼详情玻璃状态");
//                    bigStorageCageFeedTaskService.removeById(bigStorageCageFeedTask);
//                    log.info("7、删除已经完成的进片任务");
//                }
//                //启动阈值
//                if (line1Time >= 300) {
//                    if ("0".equals(plcParameterObject.getPlcParameter("D05Go").getValue())) {
//                        S7object.getinstance().plccontrol.writetime(plcParameterObject.getPlcParameter("D02Go").getAddress(), 1);
//                    }
//                }
//                if (line2Time >= 300) {
//                    if ("0".equals(plcParameterObject.getPlcParameter("D02Go").getValue())) {
//                        S7object.getinstance().plccontrol.writetime(plcParameterObject.getPlcParameter("D05Go").getAddress(), 1);
//                    }
//                }
//            }
//
//            //查询出片表是否有任务未完成的任务
//            List<BigStorageCageOutTask> bigStorageCageOutTask = bigStorageCageOutTaskService.querybigStorageCageOutTask(0);
//            if (bigStorageCageOutTask.size() == 0) {
//                boolean result = bigStorageCageService.outGlass();
//                log.info("8、没有未完成任务时调用出片接口");
//                if (result == false) {
//                    temperingGlassInfoService.schedulingTask();
//                }
//            }
//            bigStorageCageOutTaskService.updateOutTask();
//            log.info("9、根据任务表状态修改钢化小片表任务状态");
//
//            //来不及送时直接走
//            String line = Integer.toString(edgGlassTaskInfoService.startTask());
//
//            if (!(line.equals(plcFeedReqLine))) {
//                S7object.getinstance().plccontrol.writetime(plcParameterObject.getPlcParameter("D02Go").getAddress(), 1);
//            } else {
//                S7object.getinstance().plccontrol.writetime(plcParameterObject.getPlcParameter("D05Go").getAddress(), 1);
//            }
//
//
//        } catch (Exception e) {
//            e.printStackTrace();
//        }
//    }
    @Scheduled(fixedDelay = 5000)
    @Value("${mes.inCarMaxSize}")
    private Integer inCarMaxSize;

    @Value("${mes.outCarMaxSize}")
    private Integer outCarMaxSize;

    @Value("${mes.glassGap}")
    private Integer glassGap;

    private String d01GlassId = "";
    private String d04GlassId = "";

    @Scheduled(fixedDelay = 300)
    public void plcToHomeEdgScan() {
        Date startDate = new Date();
        log.info("大理片笼扫码任务开始执行时间：{}", startDate);
        PlcParameterObject plcParameterObject = S7object.getinstance().PlcMesObject;
        String d01Request = plcParameterObject.getPlcParameter("D01Request").getValue();
        String d01ID1 = plcParameterObject.getPlcParameter("D01ID1").getValue();
        String d04Request = plcParameterObject.getPlcParameter("D04Request").getValue();
        String d04ID1 = plcParameterObject.getPlcParameter("D04ID1").getValue();
        log.info("1、获取到的请求字d01为：{}，获取到的扫描ID为：{};获取到的请求字d04为：{}，获取到的扫描ID为：{};",
                d01Request, d01ID1, d04Request, d04ID1);
        if (!"1".equals(d01Request) && !"1".equals(d04Request)) {
        String d01Id = plcParameterObject.getPlcParameter("D01ID").getValue();
        String d04Id = plcParameterObject.getPlcParameter("D04ID").getValue();
        //D02id判断是否为空  确认是否空闲 允许进片
        String d02State = plcParameterObject.getPlcParameter("D02ID").getValue();
        String d03State = plcParameterObject.getPlcParameter("D03State").getValue();
        String d05State = plcParameterObject.getPlcParameter("D05State").getValue();
        String mesD01Value = plcParameterObject.getPlcParameter("MESToD01").getValue();
        String mesD04Value = plcParameterObject.getPlcParameter("MESToD04").getValue();
        String mesD01Address = plcParameterObject.getPlcParameter("MESToD01").getAddress();
        String mesD04Address = plcParameterObject.getPlcParameter("MESToD04").getAddress();
        String d01ToMES = plcParameterObject.getPlcParameter("D01ToMES").getValue();
        String d04ToMES = plcParameterObject.getPlcParameter("D04ToMES").getValue();

        log.info("1、获取d01Id扫描ID为：{}，请求字为{};获取d04Id扫描ID为：{}，请求字为{};", d01Id, d01ToMES, d04Id, d04ToMES);
        if (StringUtils.isBlank(d01ToMES) && StringUtils.isBlank(d04ToMES)) {
            log.info("两条线未收到进片任务，结束本次扫描进卧转立任务");
            return;
        }
        //        0：不干预 ； 1：条件满足情况下立即发车
        String d02GoAdress = plcParameterObject.getPlcParameter("D02Go").getAddress();
        //        0：不干预 ； 1：条件满足情况下立即发车
        String d05GoAdress = plcParameterObject.getPlcParameter("D05Go").getAddress();
        Boolean flag01 = Boolean.FALSE;
        Boolean flag04 = Boolean.FALSE;
        //按照线路及玻璃id获取相邻两块玻璃 卧转立上的玻璃
        if ("1".equals(d01Request)) {
            flag01 = judgeGlassTypeStatus(d01ID1, Const.A09_OUT_TARGET_POSITION);
        if (REQUEST_WORD.equals(d03State) && REQUEST_WORD.equals(d05State)) {
            log.info("两条线卧转立均在执行任务，结束本次扫描进卧转立任务");
            return;
        }
        if ("1".equals(d04Request)) {
            flag04 = judgeGlassTypeStatus(d04ID1, Const.A10_OUT_TARGET_POSITION);
        //按照线路及玻璃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);
                d01GlassId = d01Id;
            }
        }
        if (flag01 && flag04) {
            //比较最早一片任务的版图id及版序 求出卧转立的线路
            Integer startLine = getStartLine();
            //计算目标格子，发送启动任务
            computeTargetByLine(startLine, d02GoAdress, d05GoAdress);
        } else if (flag01 || flag04) {
            Integer startLine = flag01.equals(Boolean.TRUE) ? Const.A09_OUT_TARGET_POSITION : Const.A10_OUT_TARGET_POSITION;
            //计算目标格子，发送启动任务
            computeTargetByLine(startLine, d02GoAdress, d05GoAdress);
        } else {
            log.info("两条线未收到进片任务，结束本次扫描进卧转立任务");
//        状态为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);
                d04GlassId = d04Id;
            }
        }
        Date endDate = new Date();
        log.info("大理片笼扫码任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime());
    }

    @Scheduled(fixedDelay = 5000)
    @Scheduled(fixedDelay = 300)
    public void plcToHomeEdgFreeCarTask() {
        Date startDate = new Date();
        log.info("大理片笼空车进片任务开始执行时间：{}", startDate);
        PlcParameterObject plcParameterObject = S7object.getinstance().PlcMesObject;
        String freeCar = plcParameterObject.getPlcParameter("freeCar").getValue();
        if ("1".equals(freeCar)) {
            log.info("大车非空闲");
        String e01Status = plcParameterObject.getPlcParameter("E01State").getValue();
        String d03ToMES = plcParameterObject.getPlcParameter("D03ToMES").getValue();
        String d05ToMES = plcParameterObject.getPlcParameter("D05ToMES").getValue();
        log.info("执行空车送片任务，获取到的大车状态为{}，卧转立状态分别为d03:{}，d05:{}", e01Status, d03ToMES, d05ToMES);
        if (REQUEST_WORD.equals(e01Status)) {
            Date endDate = new Date();
            log.info("进片大车非空闲，结束送片任务，任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime());
            return;
        }
        String d01Request = plcParameterObject.getPlcParameter("D01Request").getValue();
        String d01ID1 = plcParameterObject.getPlcParameter("D01ID1").getValue();
        String d04Request = plcParameterObject.getPlcParameter("D04Request").getValue();
        String d04ID1 = plcParameterObject.getPlcParameter("D04ID1").getValue();
        log.info("1、获取到的请求字d01为：{}，获取到的扫描ID为：{};获取到的请求字d04为：{}，获取到的扫描ID为：{};",
                d01Request, d01ID1, d04Request, d04ID1);
        //两条线都有进卧转立任务，直接结束
        if (Const.BIG_STORAGE_REQUEST_IN.equals(d01Request)
                && Const.BIG_STORAGE_REQUEST_IN.equals(d04Request)
                && StringUtils.isNotBlank(d01ID1)
                && StringUtils.isNotBlank(d04ID1)) {
            log.info("两条线都存在进片任务，结束任务");
        if (!REQUEST_WORD.equals(d03ToMES) && !REQUEST_WORD.equals(d05ToMES)) {
            Date endDate = new Date();
            log.info("卧转立没有送片请求，结束送片任务，任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime());
            return;
        }
        //获取两条线卧转立是否有玻璃，且任务状态都为2
        List<String> lineList = bigStorageCageFeedTaskService.querySitToUpGlass();
        if (CollectionUtils.isEmpty(lineList)) {
            log.info("两条线卧转立为空或者有进片任务未完成，结束任务");
            return;
        }
//        0：不干预 ； 1：条件满足情况下立即发车
        String d02GoAdress = plcParameterObject.getPlcParameter("D02Go").getAddress();
        //        0：不干预 ； 1：条件满足情况下立即发车
        String d05GoAdress = plcParameterObject.getPlcParameter("D05Go").getAddress();
        String line1 = lineList.get(0);
        String flagLine = line1.equals(Const.A09_OUT_TARGET_POSITION) ? d01ID1 : d04ID1;
        if (lineList.size() == 1) {
            //发送
            if (StringUtils.isNotBlank(flagLine)) {
                return;
        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);
        //获取可以启动卧转立的任务线路
        List<BigStorageCageFeedTask> feedTaskList = bigStorageCageFeedTaskService.list(wrapper);
        if (CollectionUtils.isNotEmpty(feedTaskList)) {
            if (feedTaskList.size() == 1) {
                computeTargetByLine(feedTaskList.get(0).getLine());
            } else {
                //比较最早一片任务的版图id及版序 求出卧转立的线路
                Integer startLine = getStartLine();
//            //计算目标格子，发送启动任务
                computeTargetByLine(startLine);
            }
            //计算任务表进片格子 发送进片任务
            computeTargetByLine(Integer.parseInt(flagLine), d02GoAdress, d05GoAdress);
            Date endDate = new Date();
            log.info("大理片笼空车进片任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime());
            return;
        }
        if (StringUtils.isBlank(d01ID1) && StringUtils.isBlank(d04ID1)) {
        String d01Id = plcParameterObject.getPlcParameter("D01ID").getValue();
        String d04Id = plcParameterObject.getPlcParameter("D04ID").getValue();
        log.info("1、获取d01Id扫描ID为：{};获取d04Id扫描ID为：{};", d01Id, d04Id);
        //两条线都有进卧转立任务，直接结束
//        if (StringUtils.isNotBlank(d01Id) && StringUtils.isNotBlank(d04Id)) {
//            log.info("两条线都存在进片任务，结束任务");
//            return;
//        }
        //获取两条线卧转立是否有玻璃，且任务状态为1/2
        List<Integer> lineList = bigStorageCageFeedTaskService.querySitToUpGlass();
        if (CollectionUtils.isEmpty(lineList)) {
            Date endDate = new Date();
            log.info("两条线卧转立为空或者有进片任务未完成，结束任务，大理片笼空车进片任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime());
            return;
        }
        Integer lineFirst = lineList.get(0);
        String lineGlassId = lineFirst.equals(Const.A09_OUT_TARGET_POSITION) ? d01Id : d04Id;
        //仅有一条先符合启动启动条件
        if (lineList.size() == 1) {
            //如果进片请求但玻璃为空，计算任务表进片格子 发送进片任务
            if (StringUtils.isEmpty(lineGlassId)) {
                computeTargetByLine(lineFirst);
            } else {
                //todo:计算扫描到的玻璃是否可以存进卧转立
                //获取卧转立剩余宽度
                if (computeIsRun(lineFirst, lineGlassId)) {
                    computeTargetByLine(lineFirst);
                }
            }
            Date endDate = new Date();
            log.info("大理片笼空车进片任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime());
            return;
        }
        //两条先均可执行进片任务，判断两条线是否进片请求是否都为空
        if (StringUtils.isBlank(d01Id) && StringUtils.isBlank(d04Id)) {
            //比较最早一片任务的版图id及版序 求出卧转立的线路
            Integer line = getStartLine();
            //计算任务表进片格子 发送进片任务
            computeTargetByLine(line, d02GoAdress, d05GoAdress);
            computeTargetByLine(line);
            Date endDate = new Date();
            log.info("大理片笼空车进片任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime());
            return;
        } else if (StringUtils.isNotBlank(d01Id) && StringUtils.isNotBlank(d04Id)) {
//            todo:两个都有进片玻璃
            if (computeIsRun(Const.A09_OUT_TARGET_POSITION, d01Id) && computeIsRun(Const.A10_OUT_TARGET_POSITION, d04Id)) {
                //比较最早一片任务的版图id及版序 求出卧转立的线路
                Integer line = getStartLine();
                //计算任务表进片格子 发送进片任务
                computeTargetByLine(line);
            } else if (computeIsRun(Const.A09_OUT_TARGET_POSITION, d01Id)) {
                computeTargetByLine(Const.A09_OUT_TARGET_POSITION);
            } else if (computeIsRun(Const.A10_OUT_TARGET_POSITION, d04Id)) {
                computeTargetByLine(Const.A10_OUT_TARGET_POSITION);
            } else {
                Date endDate = new Date();
                log.info("大理片笼空车进片任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime());
                return;
            }
        } else {
            //，或者仅有一条有玻璃
            //一条线为空，一条线有进片请求有玻璃
            int outLine = StringUtils.isBlank(d01Id) ? Const.A09_OUT_TARGET_POSITION : Const.A10_OUT_TARGET_POSITION;
            //获取进片请求玻璃为空的，计算任务表进片格子 发送进片任务
            computeTargetByLine(outLine);
        }
        Date endDate = new Date();
        log.info("大理片笼空车进片任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime());
    }

    @Scheduled(fixedDelay = 300)
    public void plcToHomeEdgOutTask() {
        Date startDate = new Date();
        log.info("大理片笼空车进片任务开始执行时间：{}", startDate);
        PlcParameterObject plcMesObject = S7object.getinstance().PlcMesObject;
        String e02State = plcMesObject.getPlcParameter("E02State").getAddress();
        if (REQUEST_WORD.equals(e02State)) {
            log.info("出片忙碌，结束出片任务");
            return;
        }
        int outLine = StringUtils.isBlank(d01ID1) ? Const.A09_OUT_TARGET_POSITION : Const.A10_OUT_TARGET_POSITION;
        //计算任务表进片格子 发送进片任务
        computeTargetByLine(outLine, d02GoAdress, d05GoAdress);
        String mesToPLCAddress = plcMesObject.getPlcParameter("MESToPLC").getAddress();
        List<BigStorageCageOutTask> outingList = bigStorageCageOutTaskService.list(new LambdaQueryWrapper<BigStorageCageOutTask>().eq(BigStorageCageOutTask::getTaskState, Const.BIG_STORAGE_OUT_NEW));
        Assert.isTrue(CollectionUtils.isEmpty(outingList), "有正在执行出片的任务，结束当前出片线程");

        //是否有正在钢化的玻璃
        List<TemperingGlassInfo> temperingGlassInfoList = temperingGlassInfoService.selectJoinList(TemperingGlassInfo.class, new MPJLambdaWrapper<TemperingGlassInfo>()
                .selectAll(TemperingGlassInfo.class)
                .leftJoin(BigStorageCageOutTask.class, BigStorageCageOutTask::getGlassId, TemperingGlassInfo::getGlassId)
                .eq(TemperingGlassInfo::getState, Const.TEMPERING_NEW)
                .isNull(BigStorageCageOutTask::getGlassId)
                .orderBy(Boolean.TRUE, sequenceOrder, TemperingGlassInfo::getTemperingFeedSequence));
        if (CollectionUtils.isNotEmpty(temperingGlassInfoList)) {
            log.info("有正在出片的钢化任务");
            computeOutGlassInfo(temperingGlassInfoList, Boolean.TRUE, mesToPLCAddress);
            Date endDate = new Date();
            log.info("大理片笼出片任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime());
            return;
        }
        //是否有人工下片任务   有直接出
        List<BigStorageCageDetails> artificialList = bigStorageCageDetailsService.list(new LambdaQueryWrapper<BigStorageCageDetails>()
                .eq(BigStorageCageDetails::getState, Const.GLASS_STATE_ARTIFICIAL).orderByDesc(BigStorageCageDetails::getWidth));
        if (CollectionUtils.isNotEmpty(artificialList)) {
            computeOutGlassInfo(artificialList, Boolean.FALSE, mesToPLCAddress);
            Date endDate = new Date();
            log.info("大理片笼出片任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime());
            return;
        }
        //钢化优先：获取理片笼  玻璃小片  破损表 数量   判断笼内版图是否到齐
        List<TemperingLayoutDTO> temperingLayoutDTOList = bigStorageCageDetailsService.temperingIsAll();
        if (CollectionUtils.isNotEmpty(temperingLayoutDTOList)) {
            //玻璃到齐包括已出片的
            //到齐，将玻璃小片数据存入钢化小片表，逻辑生成出片任务  结束
            for (TemperingLayoutDTO item : temperingLayoutDTOList) {
                List<TemperingGlassInfo> temperingGlassInfos = glassInfoService.selectJoinList(TemperingGlassInfo.class, JoinWrappers.lambda(GlassInfo.class)
                        .selectAll(GlassInfo.class)
                        .select("-1 as state")
                        .selectAs(BigStorageCageDetails::getSlot, TemperingGlassInfo::getSlot)
                        .innerJoin(BigStorageCageDetails.class, BigStorageCageDetails::getGlassId, GlassInfo::getGlassId)
                        .eq(BigStorageCageDetails::getState, Const.GLASS_STATE_IN)
                        .eq(GlassInfo::getTemperingLayoutId, item.getTemperingLayoutId())
                        .eq(GlassInfo::getEngineerId, item.getEngineerId()));
                if (CollectionUtils.isNotEmpty(temperingGlassInfos)) {
                    temperingGlassInfoService.saveBatch(temperingGlassInfos);
                    computeOutGlassInfo(temperingGlassInfoList, Boolean.TRUE, mesToPLCAddress);
                    Date endDate = new Date();
                    log.info("大理片笼出片任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime());
                    return;
                }
            }
        }
        //未到齐 执行内部调度任务
        TemperingLayoutDTO temperingOccupySlot = bigStorageCageDetailsService.queryTemperingOccupySlot();
        if (null != temperingOccupySlot) {
            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) {
                    List<BigStorageCageDetails> list = bigStorageCageDetailsService.list(new LambdaQueryWrapper<BigStorageCageDetails>()
                            .eq(BigStorageCageDetails::getSlot, first.getSlot()).eq(BigStorageCageDetails::getState, Const.GLASS_STATE_IN));
                    List<BigStorageCageOutTask> outTasks = list.stream().map(e -> new BigStorageCageOutTask(e.getGlassId(), first.getSlot(), second.getSlot(),
                            slotWidth, 0, 0, 1)).collect(Collectors.toList());
                    bigStorageCageOutTaskService.saveBatch(outTasks);
                    boolean flag = Boolean.FALSE;
                    int count = 3;
                    while (!flag && count >= 0) {
                        flag = S7object.getinstance().plccontrol.writeWord(mesToPLCAddress, 1);
                        count--;
                    }
                    log.info("已向plc发送出片任务确认，地址为：{}", mesToPLCAddress);
                    Date endDate = new Date();
                    log.info("大理片笼出片任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime());
                    return;
                }
            }
        }
    }

    @Scheduled(fixedDelay = 300)
    public void updateOutGlassStateTask() {
        Date startDate = new Date();
        log.info("1、大理片笼出片完成后更新大理片笼数据任务开始执行时间：{}", startDate);
        //因为大理片笼和出片任务是两个库的数据，所以要分开查找
        List<Object> list = bigStorageCageDetailsService.listObjs(new LambdaQueryWrapper<BigStorageCageDetails>()
                .select(BigStorageCageDetails::getGlassId).eq(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());
            List<Object> outSuccessGlassIdsObj = bigStorageCageOutTaskService.listObjs(new LambdaQueryWrapper<BigStorageCageOutTask>()
                    .select(BigStorageCageOutTask::getGlassId).in(BigStorageCageOutTask::getGlassId, glassIds).in(BigStorageCageOutTask::getTaskState, Const.BIG_STORAGE_OUT_ALL));
            List<String> outSuccessGlassIds = outSuccessGlassIdsObj.stream().map(String::valueOf).collect(Collectors.toList());
            if (CollectionUtils.isNotEmpty(outSuccessGlassIds)) {
                log.info("3、获取出片已完成的玻璃信息id:{}", outSuccessGlassIdsObj);
                bigStorageCageDetailsService.update(new LambdaUpdateWrapper<BigStorageCageDetails>()
                        .set(BigStorageCageDetails::getState, Const.GLASS_STATE_OUT).in(BigStorageCageDetails::getGlassId, outSuccessGlassIds));
                log.info("4、大理片笼出片状态已完成已完成的玻璃信息id:{}", outSuccessGlassIdsObj);
            }
        }
        Date endDate = new Date();
        log.info("end:大理片笼出片完成后更新大理片笼数据任务结束时间：{}，共耗时：{}ms,结束任务", endDate, endDate.getTime() - startDate.getTime());
        return;

    }

    /**
     * 处理破损表任务
     */
    @Scheduled(fixedDelay = 300)
    public void dealDamageTask() {
        Date startDate = new Date();
        log.info("大理片笼破损玻璃清除任务开始执行时间：{}", startDate);
        //获取进片任务表中状态为破损的数据
        List<BigStorageCageFeedTask> inDamageTaskInfoList = bigStorageCageFeedTaskService.list(new LambdaQueryWrapper<BigStorageCageFeedTask>()
                .eq(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_DAMAGE));
        if (CollectionUtils.isNotEmpty(inDamageTaskInfoList)) {
            log.info("获取进片任务表中破损的玻璃信息{}", inDamageTaskInfoList);
            bigStorageCageFeedTaskService.remove(new LambdaQueryWrapper<BigStorageCageFeedTask>().eq(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_DAMAGE));
            //理片笼详情表数据状态更新
            bigStorageCageDetailsService.update(new LambdaUpdateWrapper<BigStorageCageDetails>()
                    .set(BigStorageCageDetails::getState, Const.GLASS_STATE_DAMAGE).in(BigStorageCageDetails::getGlassId, inDamageTaskInfoList.stream().map(BigStorageCageFeedTask::getGlassId).collect(Collectors.toList())));
            //将破损信息新增入破损表
            for (BigStorageCageFeedTask bigStorageCageFeedTask : inDamageTaskInfoList) {
                Damage damage = new Damage();
                damage.setGlassId(bigStorageCageFeedTask.getGlassId());
                damage.setLine(bigStorageCageFeedTask.getLine());
                damage.setWorkingProcedure("冷加工");
                damage.setRemark("进笼前卧转立");
                damage.setStatus(2);
                damageService.insertDamage(damage);
            }
            log.info("进片任务执行完成");
        }
        //获取出片任务表中状态为破损的数据
        List<BigStorageCageOutTask> outDamageTaskInfoList = bigStorageCageOutTaskService.list(new LambdaQueryWrapper<BigStorageCageOutTask>()
                .eq(BigStorageCageOutTask::getTaskState, Const.BIG_STORAGE_OUT_DAMAGE));
        if (CollectionUtils.isNotEmpty(outDamageTaskInfoList)) {
            log.info("获取出片任务表中破损的玻璃信息{}", outDamageTaskInfoList);
            bigStorageCageOutTaskService.remove(new LambdaQueryWrapper<BigStorageCageOutTask>().eq(BigStorageCageOutTask::getTaskState, Const.BIG_STORAGE_IN_DAMAGE));
            List<String> glassIdList = outDamageTaskInfoList.stream().map(BigStorageCageOutTask::getGlassId).collect(Collectors.toList());
            //移除钢化下片表数据
            temperingGlassInfoService.remove(new LambdaQueryWrapper<TemperingGlassInfo>().in(TemperingGlassInfo::getGlassId, glassIdList));
            //理片笼详情表数据状态更新
            bigStorageCageDetailsService.update(new LambdaUpdateWrapper<BigStorageCageDetails>()
                    .set(BigStorageCageDetails::getState, Const.GLASS_STATE_DAMAGE).in(BigStorageCageDetails::getGlassId, glassIdList));

            //将破损信息新增入破损表
            for (BigStorageCageOutTask bigStorageCageOutTask : outDamageTaskInfoList) {
                Damage damage = new Damage();
                damage.setGlassId(bigStorageCageOutTask.getGlassId());
                damage.setLine(bigStorageCageOutTask.getEndSlot());
                damage.setWorkingProcedure("冷加工");
                damage.setRemark("出片后卧转立");
                damage.setStatus(2);
                damageService.insertDamage(damage);
            }
            log.info("出片任务执行完成");
        }
        Date endDate = new Date();
        log.info("大理片笼破损玻璃清除任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime());
        return;
    }

    /**
     * 按照玻璃id判断玻璃状态及卧转立是否可直接启动
     */
    public Boolean judgeGlassTypeStatus(String glassId, Integer line) {
    public Boolean judgeGlassTypeStatus(String glassId, Integer line, String mesAddress) {
        //1、获取任务表中相邻玻璃
        List<EdgGlassTaskInfo> edgGlassTaskInfoList = edgGlassTaskInfoService.list(new LambdaQueryWrapper<EdgGlassTaskInfo>()
                .eq(EdgGlassTaskInfo::getLine, line)
@@ -268,45 +425,74 @@
                .orderByAsc(EdgGlassTaskInfo::getTime));
        Assert.isFalse(CollectionUtils.isEmpty(edgGlassTaskInfoList), "识别玻璃信息未出现在尺寸表中,获取相邻两块玻璃失败");
        //2、获取卧转立剩余宽度
        Map<String, Object> map = bigStorageCageFeedTaskService.getMap(new QueryWrapper<BigStorageCageFeedTask>()
                .select("cast(5000 - sum(width + 20)  as INT)as remainWidth")
                .eq("line", line).eq("task_state", Const.BIG_STORAGE_IN_UP));
        Integer remainWidth = null == map ? 5000 : Integer.parseInt(map.get("remainWidth") + "");
        BigStorageDTO sitToUpRemainWidth = bigStorageCageFeedTaskService.querySitToUpRemainWidth(line);
        Integer remainWidth;
        Integer glassCount;
        if (0 == sitToUpRemainWidth.getGlassCount()) {
            remainWidth = carWidth;
            glassCount = 0;
        } else {
            remainWidth = sitToUpRemainWidth.getWidth();
            glassCount = sitToUpRemainWidth.getGlassCount();
        }

        Boolean flag = Boolean.TRUE;
        //2、获取卧转立
        Integer widthFirst = edgGlassTaskInfoList.get(0).getWidth();
        Integer widthFirst = Math.max(edgGlassTaskInfoList.get(0).getWidth() / 10, edgGlassTaskInfoList.get(0).getHeight() / 10);
        Integer heightFirst = Math.min(edgGlassTaskInfoList.get(0).getWidth() / 10, edgGlassTaskInfoList.get(0).getHeight() / 10);
        if (edgGlassTaskInfoList.size() == 1) {
            if (remainWidth >= widthFirst) {
                addFeedTask(glassId, line, Const.BIG_STORAGE_IN_WAIT, widthFirst);
                return Boolean.FALSE;
                if (glassCount < inCarMaxSize) {
                    addFeedTask(glassId, line, Const.BIG_STORAGE_IN_WAIT, widthFirst, heightFirst);
                } else {
                    addFeedTask(glassId, line, Const.BIG_STORAGE_IN_RUN, widthFirst, heightFirst);
                }
            } else {
                //记录无法放下玻璃，后续判断启动
                return Boolean.TRUE;
                flag = Boolean.FALSE;
            }
        }
        Integer widthSecond = edgGlassTaskInfoList.get(1).getWidth();
        if (remainWidth >= widthFirst) {
            if (remainWidth - widthFirst - Const.BIG_STORAGE_GAP >= widthSecond) {
                addFeedTask(glassId, line, Const.BIG_STORAGE_IN_WAIT, widthSecond);
            } else {
                addFeedTask(glassId, line, Const.BIG_STORAGE_IN_RUN, widthSecond);
            }
            return Boolean.FALSE;

        } else {
            return Boolean.TRUE;
            Integer widthSecond = Math.max(edgGlassTaskInfoList.get(1).getWidth() / 10, edgGlassTaskInfoList.get(1).getHeight() / 10);
            Integer heightSecond = Math.min(edgGlassTaskInfoList.get(1).getWidth() / 10, edgGlassTaskInfoList.get(1).getHeight() / 10);
            if (remainWidth >= widthFirst) {
                if (remainWidth - widthFirst - glassGap >= widthSecond) {
                    if (glassCount < inCarMaxSize) {
                        addFeedTask(glassId, line, Const.BIG_STORAGE_IN_WAIT, widthFirst, heightSecond);
                    } else {
                        addFeedTask(glassId, line, Const.BIG_STORAGE_IN_RUN, widthFirst, heightSecond);
                    }
                } else {
                    addFeedTask(glassId, line, Const.BIG_STORAGE_IN_RUN, widthFirst, heightSecond);
                }
            } else {
                flag = Boolean.FALSE;
            }
        }
        //向plc发送进片确认
        if (flag) {
            boolean flagSend = Boolean.FALSE;
            int count = 3;
            while (!flagSend && count >= 0) {
                flagSend = S7object.getinstance().plccontrol.writeWord(mesAddress, 1);
                count--;
            }
            log.info("进卧转立发送确认字完成，地址为{}", mesAddress);

        }
        //记录无法放下玻璃，后续判断启动
        return flag;
    }

    /**
     * 添加任务信息
     */
    private Boolean addFeedTask(String glassId, Integer line, Integer taskType, Integer width) {
    private Boolean addFeedTask(String glassId, Integer line, Integer taskType, Integer width, Integer height) {
        BigStorageCageFeedTask bigStorageCageFeedTask = new BigStorageCageFeedTask();
        bigStorageCageFeedTask.setGlassId(glassId);
        bigStorageCageFeedTask.setTaskState(Const.BIG_STORAGE_REQUEST_IN);
        bigStorageCageFeedTask.setTaskState(Const.BIG_STORAGE_IN_NEW);
        bigStorageCageFeedTask.setLine(line);
        bigStorageCageFeedTask.setTaskType(taskType);
        bigStorageCageFeedTask.setWidth(width);
        bigStorageCageFeedTask.setHeight(height);
        bigStorageCageFeedTask.setCreateTime(new Date());
        return bigStorageCageFeedTaskService.save(bigStorageCageFeedTask);
    }
@@ -314,12 +500,13 @@
    /**
     * 获取需要启动的线路：两条线都可启动 获取第一片玻璃版图id最小 版序最大的线路
     *
     * @return
     * @return 需要启动的线路
     */
    private Integer getStartLine() {
    public Integer getStartLine() {
        List<BigStorageCageFeedTask> taskList = bigStorageCageFeedTaskService.list(new LambdaQueryWrapper<BigStorageCageFeedTask>()
                .inSql(BigStorageCageFeedTask::getId, "select min(id) from big_storage_cage_feed_task where task_state = 2 group by line"));
        Assert.isTrue(CollectionUtils.isEmpty(taskList), "卧转立两条线都没有玻璃进片任务");
                .inSql(BigStorageCageFeedTask::getId, "select min(id) from big_storage_cage_feed_task where task_state = 2" +
                        "and (target_slot = 0 or target_slot is null) group by line"));
        Assert.isFalse(CollectionUtils.isEmpty(taskList), "卧转立两条线都没有玻璃进片任务");
        Map<String, Integer> taskMap = taskList.stream().collect(Collectors.toMap(BigStorageCageFeedTask::getGlassId,
                BigStorageCageFeedTask::getLine));
        GlassInfo glassInfo = glassInfoService.getOne(new LambdaQueryWrapper<GlassInfo>()
@@ -333,47 +520,157 @@
    /**
     * 计算任务表进片线路的目标格子，并启动任务
     */
    private boolean computeTargetByLine(Integer line, String d02GoAdress, String d05GoAdress) {
    public boolean computeTargetByLine(Integer line) {
        //1、获取任务表中的所有玻璃（指定线路且已经进卧转立完成）
        List<BigStorageCageFeedTask> taskList = bigStorageCageFeedTaskService.list(new LambdaQueryWrapper<BigStorageCageFeedTask>()
                .eq(BigStorageCageFeedTask::getLine, line)
                .eq(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_UP)
                .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、去笼子内查找是否可以继续存放的笼子
        List<String> glassIds = taskList.stream().map(BigStorageCageFeedTask::getGlassId).collect(Collectors.toList());
        List<GlassInfo> glassInfos = glassInfoService.list(new LambdaQueryWrapper<GlassInfo>().in(GlassInfo::getGlassId, glassIds));
        AtomicReference<Integer> temperingLayoutIdTemp = new AtomicReference<>(0);
        AtomicReference<Integer> temperingFeedSequenceTemp = new AtomicReference<>(0);
        AtomicReference<BigStorageDTO> bigStorageDTO = new AtomicReference<>(new BigStorageDTO());
        Map<String, GlassInfo> glassInfoMap = glassInfos.stream().collect(Collectors.toMap(GlassInfo::getGlassId, p -> p));
        List<BigStorageCageDetails> bigStorageCageDetailsList = new ArrayList<>();
        taskList.stream().forEach(e -> {
            BigStorageCageDetails cageDetails = new BigStorageCageDetails();
            //按照版图信息获取进片笼子格子号
            GlassInfo info = glassInfoMap.get(e.getGlassId());
            BeanUtils.copyProperties(info, cageDetails);
            if (temperingLayoutIdTemp.equals(info.getTemperingLayoutId())
                    && temperingFeedSequenceTemp.equals(info.getTemperingFeedSequence() + 1)
                    && info.getWidth() <= bigStorageDTO.get().getWidth()) {
                bigStorageDTO.get().setWidth(bigStorageDTO.get().getWidth() - info.getWidth().intValue() - Const.BIG_STORAGE_GAP);
            } else {
                bigStorageDTO.set(bigStorageCageDetailsService.queryTargetSlotByTempering(info));
            }
            e.setTragetSlot(bigStorageDTO.get().getSlot());
            cageDetails.setSlot(bigStorageDTO.get().getSlot());
            cageDetails.setState(Const.GLASS_STATE_IN);
            temperingLayoutIdTemp.set(info.getTemperingLayoutId());
            temperingFeedSequenceTemp.set(info.getTemperingFeedSequence());
            bigStorageCageDetailsList.add(cageDetails);
        });
        //3、更新进片任务表
        boolean taskFlag = bigStorageCageFeedTaskService.updateBatchById(taskList);
        //4、在详情表中加入进片玻璃信息
        bigStorageCageDetailsService.saveBatch(bigStorageCageDetailsList);
        if (taskFlag) {
            String lineAddress = line.equals(Const.A09_OUT_TARGET_POSITION) ? d02GoAdress : d05GoAdress;
            S7object.getinstance().plccontrol.writeWord(lineAddress, (short) 1);
        }
        return taskFlag;
        return computeIsTemperingTargetByLine(glassInfos, taskList, line);
    }

    /**
     * 是否钢化玻璃进笼目标位置
     *
     * @param glassInfos 当条线卧转立所有玻璃
     * @param taskList   当条线卧转立所有任务
     * @param line       任务是哪条线
     */
    private boolean computeIsTemperingTargetByLine(List<GlassInfo> glassInfos, List<BigStorageCageFeedTask> taskList, Integer line) {
        //1、将玻璃信息集合转为glassid为key的map
        Map<String, GlassInfo> glassInfoMap = glassInfos.stream()
                .collect(Collectors.toMap(GlassInfo::getGlassId, p -> p));
        for (BigStorageCageFeedTask e : taskList) {
            GlassInfo info = glassInfoMap.get(e.getGlassId());
            if (info == null) {
                continue;
            }
            BigStorageCageDetails cageDetails = new BigStorageCageDetails();
            BeanUtils.copyProperties(info, cageDetails);
            //2、获取目标格子信息
            BigStorageDTO bigStorageDTO = bigStorageCageDetailsService.queryTargetSlotByTempering(info);
            //3、更新大理片笼表剩余宽度
            bigStorageCageService.update(new LambdaUpdateWrapper<BigStorageCage>().set(BigStorageCage::getRemainWidth, bigStorageDTO.getWidth() - info.getWidth() - glassGap)
                    .eq(BigStorageCage::getSlot, bigStorageDTO.getSlot()));
            //4、更新进片任务表，目标格子及状态（状态改为2 电气扫到自行处理）  遇到问题：无法批量更新，批量更新无法走指定从库
            e.setTargetSlot(bigStorageDTO.getSlot());
//            e.setTaskType(Const.BIG_STORAGE_IN_RUN);
            bigStorageCageFeedTaskService.updateById(e);

            //5、将进片信息存入大理片笼详情表
            cageDetails.setSlot(bigStorageDTO.getSlot());
            cageDetails.setState(Const.GLASS_STATE_IN);
            cageDetails.setDeviceId(bigStorageDTO.getDeviceId());
            cageDetails.setGap(glassGap);
            bigStorageCageDetailsService.save(cageDetails);
        }
        sendTaskListToPLC(taskList, line);
        return Boolean.TRUE;
    }

    private void sendTaskListToPLC(List<BigStorageCageFeedTask> taskList, Integer line) {
        log.info("送片任务发送进片玻璃信息");
        S7control s7control = S7object.getinstance().plccontrol;
        PlcParameterObject plcMesObject = S7object.getinstance().PlcMesObject;
        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());
        }

        s7control.writeWord(outLine, 2);
        boolean flag = Boolean.FALSE;
        int count = 3;
        while (!flag && count >= 0) {
            flag = s7control.writeWord(outLine, 2);
            count--;
        }
        log.info("送片任务已发送完成，任务线路为：{}，启动地址为{},确认字为{}", line, outLine, 2);
    }

    private <T extends BigStorageCageBaseInfo> Boolean computeOutGlassInfo(List<T> list, Boolean isTempering, String mesToPLCAddress) {
        //任务数据  获取车子存放玻璃最大数量  玻璃间隔
        List<BigStorageCageOutTask> bigStorageCageOutTaskList = new ArrayList<>();
        //打车剩余尺寸
        Integer remainWidth = carWidth;
        for (T e : list) {
            if (bigStorageCageOutTaskList.size() >= outCarMaxSize || e.getWidth() > remainWidth) {
                break;
            }
            remainWidth = remainWidth - (int) e.getWidth() - glassGap;
            if (isTempering) {
                bigStorageCageOutTaskList.add(new BigStorageCageOutTask(e.getGlassId(), e.getSlot(), Const.TEMPERING_OUT_TARGET_POSITION,
                        (int) e.getWidth() * 10, 0, 0, 1));
            } else {
                bigStorageCageOutTaskList.add(new BigStorageCageOutTask(e.getGlassId(), e.getSlot(), Const.ARTIFICIAL_OUT_TARGET_POSITION,
                        (int) e.getWidth() * 10, 0, 0, 1));
            }

        }
        Assert.isFalse(CollectionUtils.isEmpty(bigStorageCageOutTaskList), "未获取出片数据，结束出片任务");
        log.info("获取出片任务数据{}条，执行保存", bigStorageCageOutTaskList.size());
        bigStorageCageOutTaskService.saveBatch(bigStorageCageOutTaskList);
        List<String> glassIds = bigStorageCageOutTaskList.stream().map(BigStorageCageOutTask::getGlassId).collect(Collectors.toList());
        log.info("将出片玻璃{}玻璃状态改为已出片", glassIds);
        bigStorageCageDetailsService.update(new LambdaUpdateWrapper<BigStorageCageDetails>()
                .set(BigStorageCageDetails::getState, Const.GLASS_STATE_OUT_ING)
                .in(BigStorageCageDetails::getGlassId, glassIds));
        //更新笼子内格子的剩余尺寸
        updateSlotRemain(list, glassIds);

        boolean flag = Boolean.FALSE;
        int count = 3;
        while (!flag && count >= 0) {
            flag = S7object.getinstance().plccontrol.writeWord(mesToPLCAddress, 1);
            count--;
        }
        log.info("已向plc发送出片任务确认，地址为：{}", mesToPLCAddress);
        return Boolean.TRUE;
    }

    /**
     * 更新笼子内格子的剩余尺寸
     *
     * @param list         笼内可以出笼的玻璃信息
     * @param taskGlassIds 本次任务出去的玻璃ids
     * @param <T>
     */
    public <T extends BigStorageCageBaseInfo> void updateSlotRemain(List<T> list, List<String> taskGlassIds) {
        //获取需要出去（包括待出去的）的所有玻璃格子号
        List<Integer> slotList = list.stream().map(T::getSlot).distinct().collect(Collectors.toList());
        //获取待出去的玻璃信息（等待本次任务结束后下车出去的玻璃）
        Map<Integer, Double> slotRemainMap = list.stream().filter(e -> !taskGlassIds.contains(e.getGlassId()))
                .collect(Collectors.groupingBy(T::getSlot, Collectors.summingDouble(item -> item.getWidth() + glassGap)));
        if (CollectionUtils.isNotEmpty(slotRemainMap)) {
            //按照格子号更新剩余尺寸
            slotRemainMap.forEach((e, v) -> {
                bigStorageCageService.update(new LambdaUpdateWrapper<BigStorageCage>().set(BigStorageCage::getRemainWidth, slotWidth - v)
                        .eq(BigStorageCage::getSlot, e));
            });
        }
        Set<Integer> remainSlotList = slotRemainMap.keySet();
        slotList.removeAll(remainSlotList);
        if (CollectionUtils.isNotEmpty(slotList)) {
            bigStorageCageService.update(new LambdaUpdateWrapper<BigStorageCage>().set(BigStorageCage::getRemainWidth, slotWidth)
                    .in(BigStorageCage::getSlot, slotList));
        }
    }

    public Boolean computeIsRun(int line, String glassId) {
        //获取卧转立剩余宽度
        BigStorageDTO sitToUpRemainWidth = bigStorageCageFeedTaskService.querySitToUpRemainWidth(line);
        if (sitToUpRemainWidth.getGlassCount() == 0) {
            return Boolean.FALSE;
        }
        //获取玻璃信息
        GlassInfo glassInfo = glassInfoService.getOne(new LambdaQueryWrapper<GlassInfo>().eq(GlassInfo::getGlassId, glassId));
        return sitToUpRemainWidth.getWidth() < Math.max(glassInfo.getWidth(), glassInfo.getHeight());
    }

}