下篇逻辑调整：1、fixbug:进片玻璃存在可替换玻璃未进行替换 2、添加方式注释说明

zhoushihao

2024-07-11 43d838bbe517a7b8ec68685755037ec78d0e6edc

 hangzhoumesParent/moduleService/UnLoadGlassModule/src/main/java/com/mes/job/DownLoadCacheGlassTask.java

@@ -4,6 +4,7 @@
import cn.smallbun.screw.core.util.CollectionUtils;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.mes.common.S7object;
import com.mes.common.config.Const;
import com.mes.device.PlcParameterObject;
@@ -20,17 +21,16 @@
import com.mes.downworkstation.service.DownWorkstationService;
import com.mes.glassinfo.entity.GlassInfo;
import com.mes.glassinfo.service.GlassInfoService;
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.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.*;
import java.util.stream.Collectors;

/**
@@ -70,21 +70,30 @@
    @Value("${mes.maxHeight}")
    private Integer maxHeight;

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

    //    @Scheduled(fixedDelay = 1000)
    @Value("${mes.minHeight}")
    private Integer minHeight;


    @Scheduled(fixedDelay = 3000)
    public void plcHomeEdgTask() {
        PlcParameterObject plcParameterObject = S7object.getinstance().PlcMesObject;
        String requestWord = plcParameterObject.getPlcParameter("RequestWord").getValue();
        String glassIdeValue = plcParameterObject.getPlcParameter("G04ID").getValue();
        String confirmationWrodValue = plcParameterObject.getPlcParameter("MES_confirmation_word").getValue();
        String requestWord = plcParameterObject.getPlcParameter("requestWord").getValue();
        String glassIdeValue = plcParameterObject.getPlcParameter("requestID").getValue();
        //A08  A09表示线路相同  可做等价  无数据转int异常
        String out08Glassstate = plcParameterObject.getPlcParameter("A08_glass_status").getValue();
        String out10Glassstate = plcParameterObject.getPlcParameter("A10_glass_status").getValue();
        String confirmationWrodAddress = plcParameterObject.getPlcParameter("MES_confirmation_word").getAddress();
        String currentSlot = plcParameterObject.getPlcParameter("Current_slot").getValue();
        String out06Glassstate = plcParameterObject.getPlcParameter("glassStatus06").getValue();
        String out08Glassstate = plcParameterObject.getPlcParameter("glassStatus08").getValue();
        String out11Glassstate = plcParameterObject.getPlcParameter("glassStatus11").getValue();
        String out13Glassstate = plcParameterObject.getPlcParameter("glassStatus13").getValue();
        String confirmationWrodValue = plcParameterObject.getPlcParameter("confirmationWord").getValue();
        String confirmationWrodAddress = plcParameterObject.getPlcParameter("confirmationWord").getAddress();
        String currentSlot = plcParameterObject.getPlcParameter("currentCell").getValue();

        log.info("1、获取到的请求字为：{}，获取到的扫描ID为：{}，获取到的确认字为：{}，获取到的出片状态分别为：A09:{}、A10:{},当前格子号为：{}",
                requestWord, glassIdeValue, confirmationWrodValue, out08Glassstate, out10Glassstate, currentSlot);

        log.info("1、获取到的请求字为：{}，获取到的扫描ID为：{}，获取到的确认字为：{}，获取到的出片状态分别为：g06:{}、g08:{}、g11:{}、g13:{},当前格子号为：{}",
                requestWord, glassIdeValue, confirmationWrodValue, out06Glassstate, out08Glassstate, out11Glassstate, out13Glassstate, currentSlot);

        if ("0".equals(requestWord)) {
            if ("0".equals(confirmationWrodValue)) {
@@ -92,7 +101,7 @@
                return;
            }
            log.info("2、获取到的请求字为0，将确认字改为0");
            S7object.getinstance().plccontrol.writeWord(confirmationWrodAddress, (short) 0);
            S7object.getinstance().plccontrol.writeWord(confirmationWrodAddress, 0);
            return;
        }
        if (!"0".equals(confirmationWrodValue)) {
@@ -101,26 +110,23 @@
        }
        if ("1".equals(requestWord)) {
            log.info("2、进片请求，且确认字为0，执行进片任务");
            inTo(glassIdeValue, requestWord, confirmationWrodAddress, currentSlot);
            inTo(glassIdeValue, requestWord, currentSlot);
        } else if ("2".equals(requestWord)) {
            //09空闲 ：1      10空闲 ：2        都空闲：3    其他0
            log.info("2、出片请求，且确认字为0，执行进片任务");
//            outTo(Integer.parseInt(out08Glassstate),
//                    Integer.parseInt(out10Glassstate), confirmationWrodAddress, "", 0);
            log.info("2、出片请求，且确认字为0，执行出片任务");
            outTo(out06Glassstate, out08Glassstate, out11Glassstate, out13Glassstate, glassIdeValue, currentSlot);
        } else if ("3".equals(requestWord)) {
            log.info("2、进片和出片都空闲，执行出片任务");
            //加笼子里面是否有玻璃，有先出，无玻璃先进
            boolean outFlase = false;
//                    outTo(Integer.parseInt(out08Glassstate),
//                    Integer.parseInt(out10Glassstate), confirmationWrodAddress, glassIdeValue, Integer.parseInt(currentSlot));
            boolean outFlase = outTo(out06Glassstate, out08Glassstate, out11Glassstate, out13Glassstate, glassIdeValue, currentSlot);
            log.info("出片任务是否完成：{},失败且玻璃id:{}不为空则执行进片任务", outFlase, glassIdeValue);
            if (!outFlase && StringUtils.isNotBlank(glassIdeValue)) {
                inTo(glassIdeValue, requestWord, confirmationWrodAddress, currentSlot);
                inTo(glassIdeValue, requestWord, currentSlot);
            }
        }
    }

    public void inTo(String glassId, String requestWord, String confirmationWrodAddress, String currentSlot) {
    public void inTo(String glassId, String requestWord, String currentSlot) {
        log.info("1、按照玻璃id:{}获取玻璃小片信息,当前格子为:{}", glassId, currentSlot);
        //添加进片任务  查找空格
        DownStorageCage nearestEmpty = downStorageCageService.selectCacheEmpty(Integer.parseInt(currentSlot), Boolean.FALSE);
@@ -134,8 +140,8 @@
        }
        Boolean checkFlag = Boolean.FALSE;
        //玻璃尺寸是否走人工下片
        if (glassInfo.getWidth() > maxWidth || glassInfo.getHeight() > maxHeight) {
            log.info("该玻璃尺寸走人工下片,直接进片");
        if (glassInfo.getWidth() > maxWidth || glassInfo.getHeight() > maxHeight || glassInfo.getWidth() < minWidth || glassInfo.getHeight() < minHeight) {
            log.info("该玻璃尺寸不符合要求，需要走人工下片直接进片");
        } else {
            log.info("该玻璃尺寸非人工下片");
            //获取该玻璃的流程卡是否已绑定架子
@@ -151,14 +157,11 @@
            if (!checkFlag && !isBind) {
                log.info("该玻璃的流程卡未绑定架子，获取是否有空架子");
                List<DownWorkstation> list = downWorkstationService.list(new LambdaQueryWrapper<DownWorkstation>()
                        .isNull(DownWorkstation::getFlowCardId));
                        .isNull(DownWorkstation::getFlowCardId).orderByDesc(DownWorkstation::getWorkstationId));
                if (CollectionUtils.isNotEmpty(list)) {
                    log.info("有空架子,将流程卡与架子好绑定，执行进片任务 结束");
                    //绑定流程卡
                    downWorkstationService.update(new LambdaUpdateWrapper<DownWorkstation>()
                            .set(DownWorkstation::getFlowCardId, glassInfo.getFlowCardId())
                            .set(DownWorkstation::getLayer, glassInfo.getLayer())
                            .eq(DownWorkstation::getWorkstationId, list.get(0).getWorkstationId()));
                    downWorkstationService.updateFlowCardIdAndCount(glassInfo.getFlowCardId(), glassInfo.getLayer(), list.get(0).getWorkstationId());
                    checkFlag = Boolean.TRUE;
                }
            }
@@ -166,34 +169,35 @@
                log.info("无空架子,获取已绑定架子的流程卡信息,查看玻璃信息是否可被对调");
                List<DownGlassInfoDTO> downGlassInfoDTOList = downGlassInfoService.queryWorkStationIsIn(Boolean.FALSE);
                log.info("获取架子上已绑定流程卡落架的数量及未落架的玻璃数据：{}", downGlassInfoDTOList);
                if (CollectionUtils.isNotEmpty(downGlassInfoDTOList)) {
                if (CollectionUtils.isEmpty(downGlassInfoDTOList)) {
                    log.info("已绑定流程卡均无未落架玻璃，请及时处理架子上的玻璃，清除流程卡,执行进片任务");
                } else {
                    //替换玻璃信息
                    endLoop:
                    for (DownGlassInfoDTO e : downGlassInfoDTOList) {
                        List<GlassInfo> glassInfoList = e.getGlassInfoList();
                        for (GlassInfo item : glassInfoList) {
                            if (item.getWidth().equals(glassInfo.getWidth()) && item.getHeight().equals(glassInfo.getHeight())
                                    && item.getThickness().equals(glassInfo.getThickness()) && item.getFilmsid().equals(glassInfo.getFilmsid())) {
                                //玻璃是否为多层
                                checkFlag = multilayerCheck(item, Boolean.FALSE);
                                if (checkFlag) {
                                    //玻璃替换 仅替换流程卡id及层数
                                    String tempFlowCardId = item.getFlowCardId();
                                    Integer tempLayer = item.getLayer();
                                    String flowCardId = glassInfo.getFlowCardId();
                                    Integer layer = glassInfo.getLayer();
                                    log.info("替换流程卡信息,当前玻璃信息:{}的流程卡号{}及层数{},替换后玻璃信息:{}的流程卡号{}及层数{}",
                                            item, glassInfo, flowCardId, layer, tempFlowCardId, tempLayer);
                                    glassInfo.setFlowCardId(tempFlowCardId);
                                    glassInfo.setLayer(tempLayer);
                                    glassInfoService.updateById(glassInfo);
                                    item.setFlowCardId(flowCardId);
                                    item.setLayer(layer);
                                    glassInfoService.updateById(item);
                                    break endLoop;
                                }
                        Optional<GlassInfo> glassInfoTempOptional = glassInfoList.stream().filter(item -> item.getWidth() == glassInfo.getWidth() && item.getHeight() == glassInfo.getHeight()
                                && item.getThickness() == glassInfo.getThickness() && item.getFilmsid().equals(glassInfo.getFilmsid()))
                                .findFirst();
                        if (glassInfoTempOptional.isPresent()) {
                            GlassInfo item = glassInfoTempOptional.get();
                            //玻璃是否为多层
                            checkFlag = multilayerCheck(item, Boolean.FALSE);
                            if (checkFlag) {
                                //玻璃替换 仅替换流程卡id及层数
                                String tempFlowCardId = item.getFlowCardId();
                                Integer tempLayer = item.getLayer();
                                String flowCardId = glassInfo.getFlowCardId();
                                Integer layer = glassInfo.getLayer();
                                log.info("替换流程卡信息,当前玻璃信息:{}的流程卡号{}及层数{},替换后玻璃信息:{}的流程卡号{}及层数{}",
                                        item, glassInfo, flowCardId, layer, tempFlowCardId, tempLayer);
                                glassInfo.setFlowCardId(tempFlowCardId);
                                glassInfo.setLayer(tempLayer);
                                glassInfoService.updateById(glassInfo);
                                item.setFlowCardId(flowCardId);
                                item.setLayer(layer);
                                glassInfoService.updateById(item);
                                break endLoop;
                            }
                        }
                    }
@@ -206,14 +210,13 @@
        downStorageCageDetails.setState(Const.GLASS_STATE_IN);
        downStorageCageDetails.setSlot(nearestEmpty.getSlot());
        downStorageCageDetailsService.save(downStorageCageDetails);
//        生成进片任务

        //        生成进片任务
        initDownGlassTask(glassInfo, 0, nearestEmpty.getSlot(), Const.GLASS_CACHE_TYPE_IN);
        //log.info("5、生成进片任务信息存入任务表是否完成：{}", taskCache);
//        S7object.getinstance().plccontrol.writeWord(confirmationWrodAddress, (short) 1);
//        log.info("6、发送确认字完成");
    }

    public Boolean outTo(String glassStatus06, String glassStatus11, String glassStatus13, String glassId) {
    public Boolean outTo(String glassStatus06, String out08Glassstate, String glassStatus11, String
            glassStatus13, String glassId, String currentSlot) {
        if ("2".equals(glassStatus06) && "2".equals(glassStatus11) && "2".equals(glassStatus13)) {
            log.info("G06、G11、G13分别为{},{}、{}非自动状态，无法出片", glassStatus06, glassStatus11, glassStatus13);
            return Boolean.FALSE;
@@ -221,12 +224,14 @@

        List<DownStorageCageDetails> tempList = downStorageCageDetailsService.list(new LambdaQueryWrapper<DownStorageCageDetails>()
                .eq(DownStorageCageDetails::getState, Const.GLASS_STATE_IN));
        //todo:获取待进片玻璃
        //获取待进片玻璃
        DownStorageCageDetails cageDetails = new DownStorageCageDetails();
        if (StringUtils.isNotBlank(glassId)) {
            GlassInfo glassInfo = glassInfoService.getOne(new LambdaQueryWrapper<GlassInfo>().eq(GlassInfo::getGlassId, glassId));
            BeanUtils.copyProperties(glassInfo, cageDetails);
            cageDetails.setSlot(0);
            //获取当前笼子空格信息
            DownStorageCage empty = downStorageCageService.selectCacheEmpty(Integer.parseInt(currentSlot), Boolean.TRUE);
            cageDetails.setSlot(empty.getSlot());
            tempList.add(cageDetails);
        }

@@ -235,20 +240,70 @@
            log.info("笼内没有玻璃,无法执行出片");
            return Boolean.FALSE;
        }
        Boolean flag08 = "1".equals(out08Glassstate) ? Boolean.TRUE : Boolean.FALSE;
        if (!generateTaskByShelf(glassStatus06, glassStatus11, flag08, glassStatus13, tempList, cageDetails, glassId)) {
            return generateTaskByShelf(glassStatus06, glassStatus11, !flag08, glassStatus13, tempList, cageDetails, glassId);
        }
        return Boolean.TRUE;
    }

    private Boolean multilayerCheck(GlassInfo glassInfo, boolean isBind) {
        //查询该流程卡是否为多层
        if (glassInfo.getTotalLayer() > 1) {
            log.info("按照流程卡获取当前流程卡各层已落架数量");
            DownGlassInfoDTO downGlassInfoDTO = downGlassInfoService.queryDownGlassMaxLayer(glassInfo.getFlowCardId());
            if (null == downGlassInfoDTO) {
                if (isBind) {
                    return Boolean.TRUE;
                } else {
                    log.info("架子已经占满，多层玻璃无法找到对应的格子，需执行替换玻璃的操作");
                    return Boolean.FALSE;
                }

            }
            if (downGlassInfoDTO.getLayer().equals(glassInfo.getLayer())) {
                log.info("当前玻璃的流程在架子上落架最多 直接进片");
                return Boolean.TRUE;
            }
            Integer sequence = downGlassInfoService.queryMaxSequence(glassInfo.getFlowCardId(), glassInfo.getLayer());
            log.info("获取当前玻璃需要放的次序：笼内同流程 同层数的通达次序+1:{}", sequence);
            DownGlassInfo downGlassInfo = downGlassInfoService.getOne(new LambdaQueryWrapper<DownGlassInfo>()
                    .eq(DownGlassInfo::getFlowCardId, downGlassInfoDTO.getFlowCardId())
                    .eq(DownGlassInfo::getLayer, downGlassInfoDTO.getLayer()).eq(DownGlassInfo::getSequence, sequence));
            log.info("拿当前版序获取玻璃信息{}，按照次序判断当前玻璃是否尺寸对应的上（与数量最多的次序比较）。", downGlassInfo);
            if (null != downGlassInfoDTO && downGlassInfo.getWidth() == glassInfo.getWidth() && downGlassInfo.getHeight() == glassInfo.getHeight()) {
                log.info("相同次序玻璃对应上，可执行进片任务");
                return Boolean.TRUE;
            } else {
                log.info("同次序玻璃对应不上，需执行替换玻璃的操作");
                return Boolean.FALSE;
            }
        } else {
            log.info("非多层玻璃，直接进片");
            return Boolean.TRUE;
        }
    }

    private Boolean generateTaskByShelf(String glassStatus06, String glassStatus11, Boolean flag08, String
            glassStatus13, List<DownStorageCageDetails> tempList, DownStorageCageDetails cageDetails, String glassId) {
        //获取2个机械臂范围内的架子绑定的流程卡信息
        List<Integer> workList = new ArrayList();
        if (!"2".equals(glassStatus06)) {
            workList.addAll(Const.G06_WORK_STATION);
        }
        if (!"2".equals(glassStatus11)) {
            workList.addAll(Const.G11_WORK_STATION);

        if (flag08) {
            if (!"2".equals(glassStatus11)) {
                workList.addAll(Const.G11_WORK_STATION);
            }
        } else {
            if (!"2".equals(glassStatus06)) {
                workList.addAll(Const.G06_WORK_STATION);
            }
        }
        List<DownStorageCageDetails> list = new ArrayList();
        Boolean isEmptyShelf = Boolean.FALSE;
        //对笼内玻璃进行过滤，仅出符合逻辑的玻璃
        if (CollectionUtils.isNotEmpty(workList)) {
            List<DownWorkstation> downWorkstationList = downWorkstationService.list(new LambdaQueryWrapper<DownWorkstation>()
                    .eq(DownWorkstation::getEnableState, 0).in(DownWorkstation::getWorkstationId, workList));
                    .eq(DownWorkstation::getEnableState, Const.SLOT_ON).in(DownWorkstation::getWorkstationId, workList));
            log.info("架子被禁用，无法出片落架");
            if (CollectionUtils.isEmpty(downWorkstationList)) {
                log.info("笼子被禁用，无法走机械臂下片");
@@ -272,8 +327,10 @@
                }
            }
        } else {
            //直接走人工下片
            list = tempList.stream().filter(item -> item.getWidth() > maxWidth || item.getHeight() > maxHeight).collect(Collectors.toList());
            if (flag08 && !"2".equals(glassStatus13)) {
                //直接走人工下片
                list = tempList.stream().filter(item -> item.getWidth() > maxWidth || item.getHeight() > maxHeight).collect(Collectors.toList());
            }
        }
        if (CollectionUtils.isEmpty(list)) {
            log.info("笼内玻璃无法执行出片");
@@ -284,9 +341,11 @@

        for (DownStorageCageDetails item : list) {
            if (item.getWidth() > maxWidth || item.getHeight() > maxHeight) {
                log.info("玻璃宽度或高度超出阈值，执行人工下片");
                tempGlassId = item.getGlassId();
                break;
                if (flag08 && !"2".equals(glassStatus13)) {
                    log.info("玻璃宽度或高度超出阈值，执行人工下片");
                    tempGlassId = item.getGlassId();
                    break;
                }
            }
        }
        loop:
@@ -295,10 +354,8 @@
            List<DownGlassInfoDTO> downGlassInfoDTOList = downGlassInfoService.queryWorkStationIsIn(Boolean.TRUE);
            List<String> downGlassFlowList = downGlassInfoDTOList.stream().map(item -> item.getFlowCardId() + ":" + item.getLayer()).collect(Collectors.toList());
            if (CollectionUtils.isEmpty(downGlassFlowList)) {
                //架子都未绑定流程卡，出笼内子数量最多尺寸最大的玻璃
                DownStorageCageDetails downStorageCageDetails = downStorageCageDetailsService.getGlassInfoMaxCount();
                //绑定流程卡，更新玻璃状态，生成出片任务，
                tempGlassId = downStorageCageDetails.getGlassId();
                //架子都未绑定流程卡，出笼内子数量最多尺寸最大的玻璃id,无  则返回扫描扫到的玻璃id进行出片
                tempGlassId = downStorageCageDetailsService.getGlassInfoMaxCount(glassId);
                isBind = Boolean.TRUE;
                break loop;
            }
@@ -309,9 +366,8 @@
//                List<DownWorkstation> emptyShelfList = downWorkstationService.list(new LambdaQueryWrapper<DownWorkstation>()
//                        .isNull(DownWorkstation::getFlowCardId));
                if (isEmptyShelf) {
                    DownStorageCageDetails downStorageCageDetails = downStorageCageDetailsService.getGlassInfoMaxCount();
                    //绑定流程卡，更新玻璃状态，生成出片任务
                    tempGlassId = downStorageCageDetails.getGlassId();
                    //架子都未绑定流程卡，出笼内子数量最多尺寸最大的玻璃id,无  则返回扫描扫到的玻璃id进行出片
                    tempGlassId = downStorageCageDetailsService.getGlassInfoMaxCount(glassId);
                    isBind = Boolean.TRUE;
                    break loop;
                }
@@ -347,7 +403,7 @@
                    DownGlassInfo downGlassInfo = downGlassInfoService.getOne(new LambdaQueryWrapper<DownGlassInfo>()
                            .eq(DownGlassInfo::getFlowCardId, downGlassInfoDTO.getFlowCardId())
                            .eq(DownGlassInfo::getLayer, downGlassInfoDTO.getLayer()).eq(DownGlassInfo::getSequence, sequence));
                    if (null != downGlassInfoDTO && downGlassInfo.getWidth().equals(item.getWidth()) && downGlassInfo.getHeight().equals(item.getHeight())) {
                    if (null != downGlassInfoDTO && downGlassInfo.getWidth() == item.getWidth() && downGlassInfo.getHeight() == item.getHeight()) {
                        log.info("相同次序玻璃对应上，可执行进片任务");
                        //更新玻璃状态，生成出片任务
                        tempGlassId = item.getGlassId();
@@ -382,44 +438,8 @@
        }
    }

    private Boolean multilayerCheck(GlassInfo glassInfo, boolean isBind) {
        //查询该流程卡是否为多层
        if (glassInfo.getTotalLayer() > 1) {
            log.info("按照流程卡获取当前流程卡各层已落架数量");
            DownGlassInfoDTO downGlassInfoDTO = downGlassInfoService.queryDownGlassMaxLayer(glassInfo.getFlowCardId());
            if (null == downGlassInfoDTO) {
                if (isBind) {
                    return Boolean.TRUE;
                } else {
                    log.info("架子已经占满，多层玻璃无法找到对应的格子，需执行替换玻璃的操作");
                    return Boolean.FALSE;
                }

            }
            if (downGlassInfoDTO.getLayer().equals(glassInfo.getLayer())) {
                log.info("当前玻璃的流程在架子上落架最多 直接进片");
                return Boolean.TRUE;
            }
            Integer sequence = downGlassInfoService.queryMaxSequence(glassInfo.getFlowCardId(), glassInfo.getLayer());
            log.info("获取当前玻璃需要放的次序：笼内同流程 同层数的通达次序+1:{}", sequence);
            DownGlassInfo downGlassInfo = downGlassInfoService.getOne(new LambdaQueryWrapper<DownGlassInfo>()
                    .eq(DownGlassInfo::getFlowCardId, downGlassInfoDTO.getFlowCardId())
                    .eq(DownGlassInfo::getLayer, downGlassInfoDTO.getLayer()).eq(DownGlassInfo::getSequence, sequence));
            log.info("拿当前版序获取玻璃信息{}，按照次序判断当前玻璃是否尺寸对应的上（与数量最多的次序比较）。", downGlassInfo);
            if (null != downGlassInfoDTO && downGlassInfo.getWidth().equals(glassInfo.getWidth()) && downGlassInfo.getHeight().equals(glassInfo.getHeight())) {
                log.info("相同次序玻璃对应上，可执行进片任务");
                return Boolean.TRUE;
            } else {
                log.info("同次序玻璃对应不上，需执行替换玻璃的操作");
                return Boolean.FALSE;
            }
        } else {
            log.info("非多层玻璃，直接进片");
            return Boolean.TRUE;
        }
    }

    private Boolean generateDownGlassOutTask(String glassId, Integer taskType, Boolean isBind, DownStorageCageDetails cageDetails) {
    public Boolean generateDownGlassOutTask(String glassId, Integer taskType, Boolean
            isBind, DownStorageCageDetails cageDetails) {
        //按玻璃id获取玻璃信息
        DownStorageCageDetails downStorageCageDetails = null;
        if (glassId.equals(cageDetails.getGlassId())) {
@@ -427,7 +447,7 @@
            taskType = 3;
        } else {
            downStorageCageDetails = downStorageCageDetailsService.getOne(new LambdaQueryWrapper<DownStorageCageDetails>()
                    .eq(DownStorageCageDetails::getGlassId, glassId));
                    .eq(DownStorageCageDetails::getGlassId, glassId).eq(DownStorageCageDetails::getState, Const.GLASS_STATE_IN));
        }

        Integer endCell = null;
@@ -437,9 +457,7 @@
                    .isNull(DownWorkstation::getFlowCardId).orderByDesc(DownWorkstation::getWorkstationId).last("limit 1"));
            if (null != emptyDownWorkstation) {
                log.info("获取到空架子信息，绑定流程卡");
                emptyDownWorkstation.setFlowCardId(downStorageCageDetails.getFlowCardId());
                emptyDownWorkstation.setLayer(downStorageCageDetails.getLayer());
                downWorkstationService.updateById(emptyDownWorkstation);
                downWorkstationService.updateFlowCardIdAndCount(downStorageCageDetails.getFlowCardId(), downStorageCageDetails.getLayer(), emptyDownWorkstation.getWorkstationId());
                endCell = emptyDownWorkstation.getWorkstationId();
            } else {
                log.info("没有空架子信息，无法绑定流程卡");
@@ -458,6 +476,15 @@
            log.info("更新详情表内的状态失败");
            return Boolean.FALSE;
        }
        //更新落架玻璃数量
        if (endCell == 7) {
            downWorkstationService.update(new UpdateWrapper<DownWorkstation>().eq("flow_card_id", downStorageCageDetails.getFlowCardId())
                    .eq("layer", downStorageCageDetails.getLayer()).setSql("other_number = other_number +1"));
        } else {
            downWorkstationService.update(new UpdateWrapper<DownWorkstation>().eq("flow_card_id", downStorageCageDetails.getFlowCardId())
                    .eq("layer", downStorageCageDetails.getLayer()).setSql("racks_number = racks_number +1"));
        }

        //生成任务信息
        DownGlassInfo downGlassInfo = new DownGlassInfo();
        BeanUtils.copyProperties(downStorageCageDetails, downGlassInfo);
@@ -468,18 +495,36 @@
        return initDownGlassTask(glassInfo, downStorageCageDetails.getSlot(), endCell, taskType);
    }

    private Boolean initDownGlassTask(GlassInfo glassInfo, Integer startCell, Integer endCell, Integer taskType) {
    public Boolean initDownGlassTask(GlassInfo glassInfo, Integer startCell, Integer endCell, Integer taskType) {
        log.info("玻璃{}生成进片任务", glassInfo.getGlassId());
        DownGlassTask downGlassTask = new DownGlassTask();
        downGlassTask.setStartCell(startCell);
        downGlassTask.setGlassId(glassInfo.getGlassId());
        downGlassTask.setEndCell(endCell);
        downGlassTask.setTaskType(taskType + "");
        downGlassTask.setWidth(glassInfo.getWidth().intValue());
        downGlassTask.setHeight(glassInfo.getHeight().intValue());
        downGlassTask.setTaskType(taskType);
        downGlassTask.setWidth((int) glassInfo.getWidth());
        downGlassTask.setHeight((int) glassInfo.getHeight());
        downGlassTask.setFlowCardId(glassInfo.getFlowCardId());
        downGlassTask.setTaskStauts(0);
        downGlassTask.setLayer(glassInfo.getLayer());
        downGlassTask.setTaskStatus(0);
        downGlassTask.setCreateTime(new Date());
        return downGlassTaskService.save(downGlassTask);
        downGlassTaskService.save(downGlassTask);
        //向plc发送命令
        return sendMessageToPlc((int) glassInfo.getWidth(), (int) glassInfo.getHeight(), (int) glassInfo.getThickness(),
                startCell, endCell, taskType);
    }

    private Boolean sendMessageToPlc(int width, int height, int thickness, int startCell, int endCell,
                                     int taskType) {
        S7control s7control = S7object.getinstance().plccontrol;
        PlcParameterObject plcMesObject = S7object.getinstance().PlcMesObject;
        s7control.writeWord(plcMesObject.getPlcParameter("Glass_width").getAddress(), width);
        s7control.writeWord(plcMesObject.getPlcParameter("Glass_height").getAddress(), height);
        s7control.writeWord(plcMesObject.getPlcParameter("Glass_thickness").getAddress(), thickness);
        s7control.writeWord(plcMesObject.getPlcParameter("Start_cell").getAddress(), startCell);
        s7control.writeWord(plcMesObject.getPlcParameter("End_cell").getAddress(), endCell);
        s7control.writeWord(plcMesObject.getPlcParameter("task_type").getAddress(), taskType);
        s7control.writeWord(plcMesObject.getPlcParameter("confirmationWord").getAddress(), 1);
        return Boolean.TRUE;
    }
}