义乌项目
blame | 历史 | 补丁 | 提交 | 提交对比 | ignore whitespace
ZengTao
2024-09-09 09bb613cb75774426df43ecd5152aeac35e5315c 
 hangzhoumesParent/moduleService/CacheVerticalGlassModule/src/main/java/com/mes/job/PlcStorageCageTask.java


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




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;


@@ -128,14 +129,18 @@


        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;


                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);


                d04GlassId = d04Id;


                edgGlassTaskInfoService.update(new LambdaUpdateWrapper<EdgGlassTaskInfo>()


                        .set(EdgGlassTaskInfo::getStatus, Const.EDG_GLASS_SUCCESS).eq(EdgGlassTaskInfo::getGlassId, d04Id));


//                d04GlassId = d04Id;


            }


        }


        Date endDate = new Date();


@@ -146,11 +151,28 @@


    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();


        log.info("MESToD03:{},MESToD05:{}", mesD03Address, mesD05Address);


        if ("2".equals(mesD03Address) || "2".equals(mesD05Address)) {


            log.info("有启动信号，MESToD03:{},MESToD05:{}", mesD03Address, mesD05Address);


        }


        PlcParameterObject plcParameterObject = S7object.getinstance().PlcMesObject;


        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);


        List<BigStorageCageFeedTask> bigStorageCageFeedTasks = bigStorageCageFeedTaskService.list(


                new LambdaQueryWrapper<BigStorageCageFeedTask>()


                        .ne(BigStorageCageFeedTask::getTargetSlot, 0)


                        .lt(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_SLOT)


        );


        if (bigStorageCageFeedTasks.size() > 0) {


            Date endDate = new Date();


            log.info("大车有正在执行的任务{}，结束送片任务，任务结束时间：{}，共耗时：{}ms,结束扫码任务", bigStorageCageFeedTasks, endDate, endDate.getTime() - startDate.getTime());


            return;


        }


        if (REQUEST_WORD.equals(e01Status)) {


            Date endDate = new Date();


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


@@ -244,7 +266,7 @@


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


    }




    @Scheduled(fixedDelay = 5000)


    @Scheduled(fixedDelay = 10000)


    public void plcToHomeEdgOutTask() {


        Date startDate = new Date();


        log.info("大理片笼空车进片任务开始执行时间：{}", startDate);


@@ -271,16 +293,20 @@


                    .orderBy(Boolean.TRUE, sequenceOrder, TemperingGlassInfo::getTemperingFeedSequence));


            if (CollectionUtils.isNotEmpty(temperingGlassInfoList)) {


                log.info("有正在出片的钢化任务");


                computeOutGlassInfo(temperingGlassInfoList, Boolean.TRUE, mesToPLCAddress);


                computeOutMoreGlassInfo(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));


            List<BigStorageCageDetails> artificialList = bigStorageCageDetailsService.list(new LambdaQueryWrapper<BigStorageCageDetails>()


                    .eq(BigStorageCageDetails::getState, Const.GLASS_STATE_ARTIFICIAL).orderByDesc(BigStorageCageDetails::getWidth));


                    .eq(BigStorageCageDetails::getState, Const.GLASS_STATE_ARTIFICIAL)


                    .orderByAsc(BigStorageCageDetails::getSlot)


                    .orderByDesc(BigStorageCageDetails::getId));


            if (CollectionUtils.isNotEmpty(artificialList)) {


                computeOutGlassInfo(artificialList, Boolean.FALSE, mesToPLCAddress);


                computeOutMoreGlassInfo(artificialList, Boolean.FALSE, mesToPLCAddress);


                Date endDate = new Date();


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


                return;


@@ -302,7 +328,7 @@


                            .orderBy(Boolean.TRUE, sequenceOrder, GlassInfo::getTemperingFeedSequence));


                    if (CollectionUtils.isNotEmpty(temperingGlassInfos)) {


                        temperingGlassInfoService.saveBatch(temperingGlassInfos);


                        computeOutGlassInfo(temperingGlassInfoList, Boolean.TRUE, mesToPLCAddress);


                        computeOutMoreGlassInfo(temperingGlassInfoList, Boolean.TRUE, mesToPLCAddress);


                        Date endDate = new Date();


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


                        return;


@@ -313,6 +339,7 @@


        //执行内部调度任务


        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++) {


@@ -336,21 +363,24 @@


                            //更新理片笼详情表调度的后的玻璃位置信息：生成任务后先将玻璃格子位置进行调整，玻璃状态改为调度中，新增调度完成任务，处理调度完成后玻璃状态改为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()).eq(BigStorageCageDetails::getGlassId, glassList));


                            break;


                                    .set(BigStorageCageBaseInfo::getSlot, second.getSlot()).in(BigStorageCageDetails::getGlassId, glassList));


                            //两次更新笼子的剩余尺寸：第一次防止有玻璃继续进调度后的笼子，第二次更新：计算格子的实际尺寸


                            // 仅更新调度后的格子信息：起始格子完成后更新：防止调度出片过程中有新玻璃进入，


                            updateSlotRemainBySlots(Arrays.asList(second.getSlot()));


                            break loop;


                        }


                    }


                }


            }


            //向plc写入确认字


            int returnData = 0;


            int count = 1;


            while (returnData == 0) {


                log.info("已向plc第{}次送协议", count);


                S7object.getinstance().plccontrol.writeWord(mesToPLCAddress, 1);


                returnData = S7object.getinstance().plccontrol.readWord(mesToPLCAddress, 1).get(0);


                log.info("已向plc第{}次发送出片任务确认，地址为：{},写入的内容为{}", count++, mesToPLCAddress, returnData);


            }


//            //向plc写入确认字


//            int returnData = 0;


//            int count = 1;


//            while (returnData == 0) {


//                log.info("已向plc第{}次送协议", count);


//                S7object.getinstance().plccontrol.writeWord(mesToPLCAddress, 1);


//                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;


@@ -472,49 +502,56 @@


        log.info("大理片笼破损玻璃清除任务开始执行时间：{}", startDate);


        //获取进片任务表中状态为破损的数据


        List<BigStorageCageFeedTask> inDamageTaskInfoList = bigStorageCageFeedTaskService.list(new LambdaQueryWrapper<BigStorageCageFeedTask>()


                .eq(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_DAMAGE));


                .in(BigStorageCageFeedTask::getTaskState, Const.GLASS_STATE_DAMAGE_TAKE));


        if (CollectionUtils.isNotEmpty(inDamageTaskInfoList)) {


            log.info("获取进片任务表中破损的玻璃信息{}", inDamageTaskInfoList);


            bigStorageCageFeedTaskService.remove(new LambdaQueryWrapper<BigStorageCageFeedTask>().eq(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_DAMAGE));


            bigStorageCageFeedTaskService.remove(new LambdaQueryWrapper<BigStorageCageFeedTask>().in(BigStorageCageFeedTask::getTaskState, Const.GLASS_STATE_DAMAGE_TAKE));


            //理片笼详情表数据状态更新


            bigStorageCageDetailsService.update(new LambdaUpdateWrapper<BigStorageCageDetails>()


                    .set(BigStorageCageDetails::getState, Const.GLASS_STATE_DAMAGE).in(BigStorageCageDetails::getGlassId, inDamageTaskInfoList.stream().map(BigStorageCageFeedTask::getGlassId).collect(Collectors.toList())));


            bigStorageCageDetailsService.remove(new LambdaQueryWrapper<BigStorageCageDetails>()


                    .eq(BigStorageCageDetails::getState, Const.GLASS_STATE_NEW).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.setRemark("进笼前卧转立");


                damage.setStatus(2);


                damage.setStatus(0);


                damage.setType(bigStorageCageFeedTask.getTaskState());


                damageService.insertDamage(damage);


                slotList.add(bigStorageCageFeedTask.getTargetSlot());


            }


            //更新格子剩余宽度


            updateSlotRemainBySlots(slotList);


            log.info("进片任务执行完成");


        }


        //获取出片任务表中状态为破损的数据


        List<BigStorageCageOutTask> outDamageTaskInfoList = bigStorageCageOutTaskService.list(new LambdaQueryWrapper<BigStorageCageOutTask>()


                .eq(BigStorageCageOutTask::getTaskState, Const.BIG_STORAGE_OUT_DAMAGE));


                .in(BigStorageCageOutTask::getTaskState, Const.GLASS_STATE_DAMAGE_TAKE));


        if (CollectionUtils.isNotEmpty(outDamageTaskInfoList)) {


            log.info("获取出片任务表中破损的玻璃信息{}", outDamageTaskInfoList);


            bigStorageCageOutTaskService.remove(new LambdaQueryWrapper<BigStorageCageOutTask>().eq(BigStorageCageOutTask::getTaskState, Const.BIG_STORAGE_IN_DAMAGE));


            bigStorageCageOutTaskService.remove(new LambdaQueryWrapper<BigStorageCageOutTask>().in(BigStorageCageOutTask::getTaskState, Const.GLASS_STATE_DAMAGE_TAKE));


            List<String> glassIdList = outDamageTaskInfoList.stream().map(BigStorageCageOutTask::getGlassId).collect(Collectors.toList());


            //移除钢化下片表数据


            temperingGlassInfoService.update(new LambdaUpdateWrapper<TemperingGlassInfo>().in(TemperingGlassInfo::getGlassId, glassIdList)


                    .set(TemperingGlassInfo::getState, Const.TEMPERING_DAMAGE));


            //理片笼详情表数据状态更新


            bigStorageCageDetailsService.update(new LambdaUpdateWrapper<BigStorageCageDetails>()


                    .set(BigStorageCageDetails::getState, Const.GLASS_STATE_DAMAGE).in(BigStorageCageDetails::getGlassId, glassIdList));




            temperingGlassInfoService.remove(new LambdaQueryWrapper<TemperingGlassInfo>().in(TemperingGlassInfo::getGlassId, glassIdList));


            //理片笼详情表数据状态删除


            bigStorageCageDetailsService.remove(new LambdaQueryWrapper<BigStorageCageDetails>().in(BigStorageCageDetails::getGlassId, glassIdList));


            //将破损信息新增入破损表


            List<Integer> slotList = new ArrayList<>();


            for (BigStorageCageOutTask bigStorageCageOutTask : outDamageTaskInfoList) {


                Damage damage = new Damage();


                damage.setGlassId(bigStorageCageOutTask.getGlassId());


                damage.setLine(bigStorageCageOutTask.getEndSlot());


                damage.setWorkingProcedure("冷加工");


                damage.setRemark("出片后卧转立");


                damage.setStatus(2);


                damage.setStatus(0);


                damage.setType(bigStorageCageOutTask.getTaskState());


                damageService.insertDamage(damage);


                slotList.add(bigStorageCageOutTask.getStartSlot());


            }


            //更新格子剩余宽度


            updateSlotRemainBySlots(slotList);


            log.info("出片任务执行完成");


        }


        Date endDate = new Date();


@@ -527,10 +564,20 @@


     */


    public Boolean judgeGlassTypeStatus(String glassId, Integer line, String mesAddress) {


        //1、获取任务表中相邻玻璃


        List<EdgGlassTaskInfo> edgGlassTaskInfoList = edgGlassTaskInfoService.list(new LambdaQueryWrapper<EdgGlassTaskInfo>()


        List<EdgGlassTaskInfo> edgGlassTaskInfoList;


        edgGlassTaskInfoList = edgGlassTaskInfoService.list(new LambdaQueryWrapper<EdgGlassTaskInfo>()


                .eq(EdgGlassTaskInfo::getLine, line)


                .apply("time >= (select time from edg_glass_task_info where glass_id = '" + glassId + "')")


                .apply("time >= (select time from edg_glass_task_info where line='" + line + "' and glass_id = '" + glassId + "' and deleted = 0)")


                .orderByAsc(EdgGlassTaskInfo::getTime));


        if (edgGlassTaskInfoList == null) {


            log.info("线路：{}识别玻璃信息未出现在尺寸表中,获取相邻两块玻璃失败", line);


        } else {


            edgGlassTaskInfoList = edgGlassTaskInfoService.list(new QueryWrapper<EdgGlassTaskInfo>()


                    .select("Top 1 *")


                    .eq("glass_id", glassId)


            );


            log.info("在尺寸表中获取玻璃信息{}", edgGlassTaskInfoList);


        }


        Assert.isFalse(CollectionUtils.isEmpty(edgGlassTaskInfoList), "识别玻璃信息未出现在尺寸表中,获取相邻两块玻璃失败");


        //2、获取卧转立剩余宽度


        BigStorageDTO sitToUpRemainWidth = bigStorageCageFeedTaskService.querySitToUpRemainWidth(line);


@@ -553,7 +600,11 @@


                if (glassCount < inCarMaxSize) {


                    addFeedTask(glassId, line, Const.BIG_STORAGE_IN_WAIT, widthFirst, heightFirst);


                } else {


                    addFeedTask(glassId, line, Const.BIG_STORAGE_IN_RUN, widthFirst, heightFirst);


                    if (glassCount < inCarMaxSize + 1) {


                        addFeedTask(glassId, line, Const.BIG_STORAGE_IN_RUN, widthFirst, heightFirst);


                    } else {


                        return Boolean.FALSE;


                    }


                }


            } else {


                flag = Boolean.FALSE;


@@ -564,12 +615,20 @@


            if (remainWidth >= widthFirst) {


                if (remainWidth - widthFirst - glassGap >= widthSecond) {


                    if (glassCount < inCarMaxSize) {


                        addFeedTask(glassId, line, Const.BIG_STORAGE_IN_WAIT, widthFirst, heightSecond);


                        addFeedTask(glassId, line, Const.BIG_STORAGE_IN_WAIT, widthFirst, heightFirst);


                    } else {


                        addFeedTask(glassId, line, Const.BIG_STORAGE_IN_RUN, widthFirst, heightSecond);


                        if (glassCount < inCarMaxSize + 1) {


                            addFeedTask(glassId, line, Const.BIG_STORAGE_IN_RUN, widthFirst, heightFirst);


                        } else {


                            return Boolean.FALSE;


                        }


                    }


                } else {


                    addFeedTask(glassId, line, Const.BIG_STORAGE_IN_RUN, widthFirst, heightSecond);


                    if (glassCount < inCarMaxSize + 1) {


                        addFeedTask(glassId, line, Const.BIG_STORAGE_IN_RUN, widthFirst, heightFirst);


                    } else {


                        return Boolean.FALSE;


                    }


                }


            } else {


                flag = Boolean.FALSE;


@@ -603,6 +662,8 @@


        bigStorageCageFeedTask.setWidth(width);


        bigStorageCageFeedTask.setHeight(height);


        bigStorageCageFeedTask.setCreateTime(new Date());


        //删除理片笼表拿走/破损数据数据


        damageService.deleteByGlassId(glassId);


        return bigStorageCageFeedTaskService.save(bigStorageCageFeedTask);


    }




@@ -662,9 +723,9 @@


            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()));


            //3、临时更新格子的剩余尺寸：防止相邻玻璃进同一格子造成剩余尺寸不足，玻璃越界的情况，任务完成后再次更新大理片笼表剩余宽度（按照笼内玻璃数量更新大理片笼剩余尺寸）


            bigStorageCageService.update(new LambdaUpdateWrapper<BigStorageCage>().set(BigStorageCage::getRemainWidth, bigStorageDTO.getWidth() - Math.max(info.getWidth(), info.getHeight()) - glassGap)


                    .eq(BigStorageCage::getSlot, bigStorageDTO.getSlot()));


            //4、更新进片任务表，目标格子及状态（状态改为2 电气扫到自行处理）  遇到问题：无法批量更新，批量更新无法走指定从库


            e.setTargetSlot(bigStorageDTO.getSlot());


            bigStorageCageFeedTaskService.updateById(e);


@@ -675,6 +736,7 @@


            cageDetails.setDeviceId(bigStorageDTO.getDeviceId());


            cageDetails.setGap(glassGap);


            bigStorageCageDetailsService.save(cageDetails);




        }


        sendTaskListToPLC(taskList, line);


        return Boolean.TRUE;


@@ -690,51 +752,50 @@


        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);


            log.info("向plc发送第{}片玻璃已完成,起始位置是{}，目标位置是", i, taskList.get(i - 1).getLine(), taskList.get(i - 1).getTargetSlot());


        }


        int returnData = 0;


        int count = 1;


        while (returnData == 0) {


            s7control.writeWord(outLine, 2);


            returnData = s7control.readWord(outLine, 1).get(0);


            log.info("已向plc第{}次发送出片任务确认，地址为：{},写入的内容为{}", count++, outLine, returnData);


            log.info("已向plc第{}次发送进片任务确认，地址为：{},写入的内容为{}", count++, outLine, returnData);


        }


    }




    /**


     * 出片一次仅生成一车玻璃


     *


     * @param list


     * @param isTempering


     * @param mesToPLCAddress


     * @param <T>


     * @return


     */


    private <T extends BigStorageCageBaseInfo> Boolean computeOutGlassInfo(List<T> list, Boolean isTempering, String mesToPLCAddress) {


        //任务数据  获取车子存放玻璃最大数量  玻璃间隔


        List<BigStorageCageOutTask> bigStorageCageOutTaskList = new ArrayList<>();


        //打车剩余尺寸


        Integer remainWidth = carWidth;


        int trainNumber = 1;


        int serialNumber = 1;


        int maxX = 0;


        for (T e : list) {


            int maxLength = Math.max((int) e.getWidth(), (int) e.getHeight());


            if (bigStorageCageOutTaskList.size() >= outCarMaxSize || maxLength > remainWidth) {


                remainWidth = carWidth;


                trainNumber = trainNumber + 1;


                serialNumber = 1;


                maxX = 0;


                continue;


            if (bigStorageCageOutTaskList.size() >= outCarMaxSize || Math.max((int) e.getWidth(), (int) e.getHeight()) > remainWidth) {


                break;


            }


            remainWidth = remainWidth - maxLength - glassGap;


            remainWidth = remainWidth - Math.max((int) e.getWidth(), (int) e.getHeight()) - glassGap;


            if (isTempering) {


                int minLength = Math.min((int) e.getWidth(), (int) e.getHeight());


                if (maxX + minLength <= xMaxSize) {


                    bigStorageCageOutTaskList.add(new BigStorageCageOutTask(e.getGlassId(), e.getSlot(), Const.TEMPERING_OUT_TARGET_POSITION,


                            e.getWidth() * 10, e.getHeight() * 10, trainNumber, serialNumber++, 1));


                            e.getWidth() * 10, e.getHeight() * 10, 0, 0, 1));


                    maxX = Math.max(maxX, e.getXCoordinate());


                } else {


                    remainWidth = carWidth;


                    trainNumber = trainNumber + 1;


                    serialNumber = 1;


                    maxX = 0;


                    continue;


                    break;


                }




            } else {


                bigStorageCageOutTaskList.add(new BigStorageCageOutTask(e.getGlassId(), e.getSlot(), Const.ARTIFICIAL_OUT_TARGET_POSITION,


                        e.getWidth() * 10, e.getHeight(), trainNumber, serialNumber++, 1));


                        e.getWidth() * 10, e.getHeight(), 0, 0, 1));


            }


        }


        Assert.isFalse(CollectionUtils.isEmpty(bigStorageCageOutTaskList), "未获取出片数据，结束出片任务");


@@ -755,6 +816,69 @@


        return Boolean.TRUE;


    }




    /**


     * 出片一次生成一炉玻璃


     *


     * @param list


     * @param isTempering


     * @param mesToPLCAddress


     * @param <T>


     * @return


     */


    private <T extends BigStorageCageBaseInfo> Boolean computeOutMoreGlassInfo(List<T> list, Boolean isTempering, String mesToPLCAddress) {


        //任务数据  获取车子存放玻璃最大数量  玻璃间隔


        List<BigStorageCageOutTask> bigStorageCageOutTaskList = new ArrayList<>();


        //打车剩余尺寸


        Integer remainWidth = carWidth;


        int trainNumber = 1;


        int serialNumber = 1;


        int maxX = 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) {


                    bigStorageCageOutTaskList.add(new BigStorageCageOutTask(e.getGlassId(), e.getSlot(), Const.TEMPERING_OUT_TARGET_POSITION,


                            e.getWidth() * 10, e.getHeight() * 10, trainNumber, serialNumber++, 1));


                    maxX = Math.max(maxX, e.getXCoordinate());


                } else {


                    remainWidth = carWidth - maxLength - glassGap;


                    trainNumber = trainNumber + 1;


                    serialNumber = 1;


                    maxX = e.getXCoordinate();


                    bigStorageCageOutTaskList.add(new BigStorageCageOutTask(e.getGlassId(), e.getSlot(), Const.TEMPERING_OUT_TARGET_POSITION,


                            e.getWidth() * 10, e.getHeight(), trainNumber, serialNumber++, 1));


                }


            } else {


                bigStorageCageOutTaskList.add(new BigStorageCageOutTask(e.getGlassId(), e.getSlot(), Const.ARTIFICIAL_OUT_TARGET_POSITION,


                        e.getWidth() * 10, e.getHeight(), trainNumber, serialNumber++, 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));


//        int returnData = 0;


//        int count = 1;


//        while (returnData == 0) {


//            S7object.getinstance().plccontrol.writeWord(mesToPLCAddress, 1);


//            returnData = S7object.getinstance().plccontrol.readWord(mesToPLCAddress, 1).get(0);


//            log.info("已向plc第{}次发送出片任务确认，地址为：{},写入的内容为{}", count++, mesToPLCAddress, returnData);


//        }


        return Boolean.TRUE;


    }




    public void updateSlotRemainBySlots(List<Integer> slotList) {


        //获取格子内所有的玻璃信息


        List<BigStorageCageDetails> inSlotGlassList = bigStorageCageDetailsService.list(new LambdaQueryWrapper<BigStorageCageDetails>()


@@ -764,9 +888,10 @@


        if (CollectionUtils.isNotEmpty(inSlotGlassList)) {


            //存在  将格子内的玻璃分别进行更新


            slotRemainMap = inSlotGlassList.stream()


                    .collect(Collectors.groupingBy(BigStorageCageDetails::getSlot, Collectors.summingDouble(item -> item.getWidth() + glassGap)));


                    .collect(Collectors.groupingBy(BigStorageCageDetails::getSlot, Collectors.summingDouble(item -> Math.max(item.getWidth(), item.getHeight()) + glassGap)));


            slotRemainMap.forEach((e, v) -> {


                bigStorageCageService.update(new LambdaUpdateWrapper<BigStorageCage>().set(BigStorageCage::getRemainWidth, slotWidth - v)


                double remainWidth = slotWidth - v >= 0 ? slotWidth - v : 0;


                bigStorageCageService.update(new LambdaUpdateWrapper<BigStorageCage>().set(BigStorageCage::getRemainWidth, remainWidth)


                        .eq(BigStorageCage::getSlot, e));


            });


        }