大理片笼:进出笼状态修改按照玻璃id和笼内格子位置

zhoushihao

2024-07-26 b3fd4ee6e9d4ae51cde28be8ae705e19af5ef9e4

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

@@ -16,6 +16,7 @@
import com.mes.bigstorage.service.BigStorageCageService;
import com.mes.bigstoragetask.entity.BigStorageCageFeedTask;
import com.mes.bigstoragetask.entity.BigStorageCageOutTask;
import com.mes.bigstoragetask.entity.UpdateBigStorageCageDTO;
import com.mes.bigstoragetask.service.BigStorageCageFeedTaskService;
import com.mes.bigstoragetask.service.BigStorageCageOutTaskService;
import com.mes.common.S7object;
@@ -84,6 +85,10 @@

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

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


    private String d01GlassId = "";
    private String d04GlassId = "";
@@ -290,7 +295,8 @@
                        .innerJoin(BigStorageCageDetails.class, BigStorageCageDetails::getGlassId, GlassInfo::getGlassId)
                        .eq(BigStorageCageDetails::getState, Const.GLASS_STATE_IN)
                        .eq(GlassInfo::getTemperingLayoutId, item.getTemperingLayoutId())
                        .eq(GlassInfo::getEngineerId, item.getEngineerId()));
                        .eq(GlassInfo::getEngineerId, item.getEngineerId())
                        .orderBy(Boolean.TRUE, sequenceOrder, GlassInfo::getTemperingFeedSequence));
                if (CollectionUtils.isNotEmpty(temperingGlassInfos)) {
                    temperingGlassInfoService.saveBatch(temperingGlassInfos);
                    computeOutGlassInfo(temperingGlassInfoList, Boolean.TRUE, mesToPLCAddress);
@@ -313,21 +319,59 @@
                    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());
                            e.getWidth() * 10, e.getHeight() * 10, 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--;

                    //向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);
                    }
                    log.info("已向plc发送出片任务确认，地址为：{}", mesToPLCAddress);
                    Date endDate = new Date();
                    log.info("大理片笼出片任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime());
                    return;
                }
            }
        }
    }

    @Scheduled(fixedDelay = 300)
    public void updateInGlassStateTask() {
        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_NEW));
        if (CollectionUtils.isNotEmpty(list)) {
            log.info("2、获取所有正在进片的玻璃信息id:{}", list);
            List<String> glassIds = list.stream().map(String::valueOf).collect(Collectors.toList());
            List<BigStorageCageFeedTask> inSuccessGlass = bigStorageCageFeedTaskService.list(new LambdaQueryWrapper<BigStorageCageFeedTask>()
                    .in(BigStorageCageFeedTask::getGlassId, glassIds)
                    .in(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_SLOT));
            if (CollectionUtils.isNotEmpty(inSuccessGlass)) {
                log.info("3、获取进片已完成的玻璃信息id:{}", inSuccessGlass);
                List<String> inSuccessGlassIds = inSuccessGlass.stream().map(BigStorageCageFeedTask::getGlassId).collect(Collectors.toList());
                List<UpdateBigStorageCageDTO> storageCageDTOList = inSuccessGlass.stream().map(e -> {
                    UpdateBigStorageCageDTO storageCageDTO = new UpdateBigStorageCageDTO();
                    BeanUtils.copyProperties(inSuccessGlass, storageCageDTO);
                    return storageCageDTO;
                }).collect(Collectors.toList());
                bigStorageCageDetailsService.updateBySlot(storageCageDTOList, Const.GLASS_STATE_IN);
                log.info("4、大理片笼进片状态已完成已完成的玻璃信息id:{}", inSuccessGlassIds);
                //更新理片笼玻璃尺寸
                updateSlotRemain(inSuccessGlassIds, Boolean.TRUE);
                log.info("5、大理片笼进片目标格子尺寸更新完成");
            }

        }
        Date endDate = new Date();
        log.info("end:大理片笼进片完成后更新大理片笼数据任务结束时间：{}，共耗时：{}ms,结束任务", endDate, endDate.getTime() - startDate.getTime());
        return;

    }

    @Scheduled(fixedDelay = 300)
@@ -340,14 +384,21 @@
        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>()
            List<BigStorageCageOutTask> outSuccessGlass = bigStorageCageOutTaskService.list(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);
            if (CollectionUtils.isNotEmpty(outSuccessGlass)) {
                log.info("3、获取出片已完成的玻璃信息id:{}", outSuccessGlass);
                List<UpdateBigStorageCageDTO> storageCageDTOList = outSuccessGlass.stream().map(e -> {
                    UpdateBigStorageCageDTO storageCageDTO = new UpdateBigStorageCageDTO();
                    BeanUtils.copyProperties(outSuccessGlass, storageCageDTO);
                    return storageCageDTO;
                }).collect(Collectors.toList());
                bigStorageCageDetailsService.updateBySlot(storageCageDTOList, Const.GLASS_STATE_OUT);
                List<String> outSuccessGlassIds = outSuccessGlass.stream().map(BigStorageCageOutTask::getGlassId).collect(Collectors.toList());
                log.info("4、大理片笼出片状态已完成已完成的玻璃信息id:{}", outSuccessGlassIds);
                //更新理片笼玻璃尺寸
                updateSlotRemain(outSuccessGlassIds, Boolean.FALSE);
                log.info("5、大理片笼进片目标格子尺寸更新完成");
            }
        }
        Date endDate = new Date();
@@ -469,14 +520,15 @@
        }
        //向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);
            //向plc写入确认字
            int returnData = 0;
            int count = 1;
            while (returnData == 0) {
                S7object.getinstance().plccontrol.writeWord(mesAddress, 1);
                returnData = S7object.getinstance().plccontrol.readWord(mesAddress, 1).get(0);
                log.info("进卧转立第{}次发送确认字完成，地址为：{},写入的内容为{}", count++, mesAddress, returnData);

            }
        }
        //记录无法放下玻璃，后续判断启动
        return flag;
@@ -553,17 +605,16 @@
            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() - 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.setState(Const.GLASS_STATE_NEW);
            cageDetails.setDeviceId(bigStorageDTO.getDeviceId());
            cageDetails.setGap(glassGap);
            bigStorageCageDetailsService.save(cageDetails);
@@ -583,15 +634,13 @@
            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--;
        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("送片任务已发送完成，任务线路为：{}，启动地址为{},确认字为{}", line, outLine, 2);
    }

    private <T extends BigStorageCageBaseInfo> Boolean computeOutGlassInfo(List<T> list, Boolean isTempering, String mesToPLCAddress) {
@@ -599,17 +648,25 @@
        List<BigStorageCageOutTask> bigStorageCageOutTaskList = new ArrayList<>();
        //打车剩余尺寸
        Integer remainWidth = carWidth;
        int maxX = 0;
        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));
                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, 0, 0, 1));
                    maxX = Math.max(maxX, e.getXCoordinate());
                } else {
                    break;
                }

            } else {
                bigStorageCageOutTaskList.add(new BigStorageCageOutTask(e.getGlassId(), e.getSlot(), Const.ARTIFICIAL_OUT_TARGET_POSITION,
                        (int) e.getWidth() * 10, 0, 0, 1));
                        e.getWidth() * 10, e.getHeight(), 0, 0, 1));
            }

        }
@@ -621,45 +678,60 @@
        bigStorageCageDetailsService.update(new LambdaUpdateWrapper<BigStorageCageDetails>()
                .set(BigStorageCageDetails::getState, Const.GLASS_STATE_OUT_ING)
                .in(BigStorageCageDetails::getGlassId, glassIds));
        //更新笼子内格子的剩余尺寸
        updateSlotRemain(list, glassIds);
        //更新笼子内格子的剩余尺寸(移至出片任务完成后)
//        updateSlotRemain(list, glassIds);

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

    /**
     * 更新笼子内格子的剩余尺寸
     *
     * @param list         笼内可以出笼的玻璃信息
     * @param taskGlassIds 本次任务出去的玻璃ids
     * @param <T>
     * @param flag         是否进出片 true 进片  false 出片
     */
    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)));
    public void updateSlotRemain(List<String> taskGlassIds, Boolean flag) {
        //按照玻璃id获取玻璃信息及玻璃的格子号
        List<BigStorageCageDetails> glassList = bigStorageCageDetailsService.list(new LambdaQueryWrapper<BigStorageCageDetails>()
                .in(BigStorageCageDetails::getGlassId, taskGlassIds));
        //获取需要出去/进笼（包括待出去的）的所有玻璃格子号
        List<Integer> slotList = glassList.stream().map(BigStorageCageDetails::getSlot).distinct().collect(Collectors.toList());
        //获取格子内所有的玻璃信息
        List<BigStorageCageDetails> inSlotGlassList = bigStorageCageDetailsService.list(new LambdaQueryWrapper<BigStorageCageDetails>()
                .in(BigStorageCageDetails::getSlot, slotList).in(BigStorageCageDetails::getState, Const.GLASS_STATE_IN_ALL));
        //获取待进片/出去的玻璃信息
        Map<Integer, Double> slotRemainMap = null;
        if (flag) {
            slotRemainMap = inSlotGlassList.stream().filter(e -> taskGlassIds.contains(e.getGlassId()))
                    .collect(Collectors.groupingBy(BigStorageCageDetails::getSlot, Collectors.summingDouble(item -> item.getWidth() + glassGap)));
        } else {
            slotRemainMap = inSlotGlassList.stream().filter(e -> !taskGlassIds.contains(e.getGlassId()))
                    .collect(Collectors.groupingBy(BigStorageCageDetails::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));
        //只更新进笼完成的状态，如果进笼完成，格子内必定有玻璃，不存在出片后格子内没有玻璃的情况，所有格子尺寸重置，只能存在于出片任务
        if (!flag) {
            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) {