1、 钢化前理片笼进片/直通已开发，调度框架已搭建等待补充

zhoushihao

2025-10-22 b049e8f345c6725899fcfbe2da89548500515fba

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

@@ -152,7 +152,7 @@
                task.setStartSlot(Integer.parseInt(fromOpcUa));
                inTaskList.add(task);
                glassIdList.add(requestWord);
                continue;
                break;
            }
        }
        if (CollectionUtil.isEmpty(inTaskList)) {
@@ -219,15 +219,16 @@
            return;
        }
        Integer glassGap = sysConfigService.queryConfigValue(ConstSysConfig.VERTICAL_GLASS_GAP);
        Integer slotMaxthickness = sysConfigService.queryConfigValue(ConstSysConfig.VERTICAL_SLOT_MAX_THICKNESS);
        Integer slotMaxThickness = sysConfigService.queryConfigValue(ConstSysConfig.VERTICAL_SLOT_MAX_THICKNESS);
        Integer slotWidth = sysConfigService.queryConfigValue(ConstSysConfig.VERTICAL_SLOT_WIDTH);
        Integer slotMaxHeight = sysConfigService.queryConfigValue(ConstSysConfig.VERTICAL_SLOT_MAX_HEIGHT);
        //按照玻璃厚度分组，判断剩余格子是否可以存放
        Map<Double, Long> thickCountMap = glassInfoList.stream().collect(Collectors.groupingBy(GlassInfo::getThickness, Collectors.counting()));
        if (glassInfoList.get(0).getThickness() < slotMaxthickness) {
        if (glassInfoList.get(0).getThickness() < slotMaxThickness) {
            for (Map.Entry<Double, Long> entry : thickCountMap.entrySet()) {
                int count = bigStorageCageService.count(new LambdaQueryWrapper<BigStorageCage>()
                        .eq(BigStorageCage::getEnableState, Const.SLOT_ON).eq(BigStorageCage::getRemainWidth, slotWidth)
                        .ge(BigStorageCage::getDeviceId, 4)
                        .le(BigStorageCage::getMinThickness, entry.getKey())
                        .ge(BigStorageCage::getMaxThickness, entry.getKey()));
                if (count < entry.getValue()) {
@@ -242,7 +243,7 @@
            }
        }
        //超大尺寸
        if (slotMaxHeight < Math.min(glassInfoList.get(0).getWidth(), glassInfoList.get(0).getHeight()) || glassInfoList.get(0).getThickness() >= slotMaxthickness) {
        if (slotMaxHeight < Math.min(glassInfoList.get(0).getWidth(), glassInfoList.get(0).getHeight()) || glassInfoList.get(0).getThickness() >= slotMaxThickness) {
            int count = bigStorageCageDetailsService.count(new LambdaQueryWrapper<BigStorageCageDetails>()
                    .eq(BigStorageCageDetails::getSlot, THROUGH_SLOT)
                    .in(BigStorageCageDetails::getState, Const.GLASS_STATE_IN_ALL));
@@ -262,14 +263,15 @@
                .set(EdgGlassTaskInfo::getState, Const.EDG_GLASS_SUCCESS).in(EdgGlassTaskInfo::getGlassId, glassIdList));
        //报工
        for (String glass : glassIdList) {
            damageService.autoSubmitReport(glass, inTaskList.get(0).getStartSlot(), "磨边", "进大理片笼", 1);
            damageService.autoSubmitReport(glass, inTaskList.get(0).getStartSlot(),
                    "磨边", "进大理片笼", 1);
        }

        Map<String, List<GlassInfo>> glassListMap = glassInfoList.stream().collect(Collectors.groupingBy(GlassInfo::getGlassId));
        //计算目标格子
        List<BigStorageCageHistoryTask> historyTasks = new ArrayList<>();
        //超大尺寸与正常尺寸玻璃计算方式不一样
        if (slotMaxHeight > Math.min(glassInfoList.get(0).getWidth(), glassInfoList.get(0).getHeight()) && glassInfoList.get(0).getThickness() < slotMaxthickness) {
        if (slotMaxHeight > Math.min(glassInfoList.get(0).getWidth(), glassInfoList.get(0).getHeight()) && glassInfoList.get(0).getThickness() < slotMaxThickness) {
            for (BigStorageCageTask task : inTaskList) {
                GlassInfo info = glassListMap.get(task.getGlassId()).get(0);
                BigStorageDTO bigStorageDTO = bigStorageGlassInfoService.queryBigStorageTargetSlot(info.getEngineerId(), info.getTemperingLayoutId(), info.getTemperingFeedSequence());
@@ -301,27 +303,29 @@
                bigStorageCageDetailsService.save(cageDetails);
            }
        } else {
            BigStorageCageTask task = inTaskList.get(0);
            task.setTargetSlot(THROUGH_SLOT);
            //存放历史任务
            BigStorageCageHistoryTask historyTask = new BigStorageCageHistoryTask();
            BeanUtils.copyProperties(task, historyTask);
            historyTask.setTaskType(Const.BIG_STORAGE_BEFORE_IN);
            historyTask.setGlassCount(glassInfoList.size());
            historyTask.setTaskState(Const.ENGINEERING_NEW);
            historyTasks.add(historyTask);
            GlassInfo info = glassInfoList.get(0);
            BigStorageCageDetails cageDetails = new BigStorageCageDetails();
            BeanUtils.copyProperties(info, cageDetails);
            cageDetails.setSlot(THROUGH_SLOT);
            cageDetails.setState(Const.GLASS_STATE_NEW);
            cageDetails.setDeviceId(0);
            cageDetails.setSequence(0);
            cageDetails.setGap(glassGap);
            cageDetails.setAngle((int) info.getAngle());
            cageDetails.setFilmsId(info.getFilmsid());
            cageDetails.setId(null);
            bigStorageCageDetailsService.save(cageDetails);
            for (BigStorageCageTask task : inTaskList) {
                task.setTargetSlot(THROUGH_SLOT);
                //存放历史任务
                BigStorageCageHistoryTask historyTask = new BigStorageCageHistoryTask();
                BeanUtils.copyProperties(task, historyTask);
                historyTask.setTaskType(Const.BIG_STORAGE_BEFORE_IN);
                historyTask.setGlassCount(glassInfoList.size());
                historyTask.setTaskState(Const.ENGINEERING_NEW);
                historyTasks.add(historyTask);
                GlassInfo info = glassListMap.get(task.getGlassId()).get(0);
                BigStorageCageDetails cageDetails = new BigStorageCageDetails();
                BeanUtils.copyProperties(info, cageDetails);
                cageDetails.setSlot(THROUGH_SLOT);
                cageDetails.setState(Const.GLASS_STATE_NEW);
                cageDetails.setDeviceId(0);
                cageDetails.setSequence(0);
                cageDetails.setGap(glassGap);
                cageDetails.setAngle((int) info.getAngle());
                cageDetails.setFilmsId(info.getFilmsid());
                cageDetails.setId(null);
                bigStorageCageDetailsService.save(cageDetails);
            }

        }
        //历史数据入库
        bigStorageCageHistoryTaskService.saveBatch(historyTasks);
@@ -377,6 +381,67 @@
            log.info("有正在执行的出片任务，结束本次出片任务");
            return;
        }

        List<BigStorageCageDetails> detailsList = bigStorageCageDetailsService.list(new LambdaQueryWrapper<BigStorageCageDetails>()
                .eq(BigStorageCageDetails::getSlot, THROUGH_SLOT)
                .in(BigStorageCageDetails::getState, Const.GLASS_STATE_IN_ALL).orderByAsc(BigStorageCageDetails::getId));
        if (CollectionUtil.isNotEmpty(detailsList)) {
            List<BigStorageCageHistoryTask> historyTasks = new ArrayList<>();
            List<BigStorageCageTask> taskList = new ArrayList<>();
            Integer glassGap = sysConfigService.queryConfigValue(ConstSysConfig.VERTICAL_GLASS_GAP);
            Integer slotWidth = sysConfigService.queryConfigValue(ConstSysConfig.VERTICAL_SLOT_WIDTH);
            Integer slotMaxThickness = sysConfigService.queryConfigValue(ConstSysConfig.VERTICAL_SLOT_MAX_THICKNESS);
            Integer slotMaxHeight = sysConfigService.queryConfigValue(ConstSysConfig.VERTICAL_SLOT_MAX_HEIGHT);
            for (BigStorageCageDetails info : detailsList) {
                BigStorageCageTask task = new BigStorageCageTask();
                task.setGlassId(info.getGlassId());
                task.setStartSlot(THROUGH_SLOT);
                task.setTaskState(Const.ENGINEERING_NEW);

                LambdaQueryWrapper<BigStorageCage> queryWrapper = new LambdaQueryWrapper<BigStorageCage>()
                        .eq(BigStorageCage::getRemainWidth, slotWidth).orderByAsc(BigStorageCage::getSlot)
                        .eq(BigStorageCage::getEnableState, Const.SLOT_ON)
                        .last("limit 1");

                if (slotMaxHeight > Math.min(info.getWidth(), info.getHeight()) && info.getThickness() < slotMaxThickness) {
                    queryWrapper.in(BigStorageCage::getDeviceId, Arrays.asList(5, 6));
                } else {
                    queryWrapper.eq(BigStorageCage::getDeviceId, 6);
                }

                BigStorageCage bigStorageCage = bigStorageCageService.getOne(queryWrapper);
                //获取目标格子信息
//            临时更新格子的剩余尺寸：防止相邻玻璃进同一格子造成剩余尺寸不足，玻璃越界的情况，任务完成后再次更新大理片笼表剩余宽度（按照笼内玻璃数量更新大理片笼剩余尺寸）
                bigStorageCageService.update(new LambdaUpdateWrapper<BigStorageCage>()
                        .set(BigStorageCage::getRemainWidth, bigStorageCage.getRemainWidth() - Math.max(info.getWidth(), info.getHeight()) - glassGap)
                        .eq(BigStorageCage::getSlot, bigStorageCage.getSlot()));
                task.setTargetSlot(bigStorageCage.getSlot());
                taskList.add(task);
                //存放历史任务
                BigStorageCageHistoryTask historyTask = new BigStorageCageHistoryTask();
                BeanUtils.copyProperties(task, historyTask);
                historyTask.setTaskType(Const.BIG_STORAGE_BEFORE_DISPATCH);
                historyTask.setGlassCount(detailsList.size());
                historyTask.setTaskState(Const.ENGINEERING_NEW);
                historyTasks.add(historyTask);
                BigStorageCageDetails cageDetails = new BigStorageCageDetails();
                BeanUtils.copyProperties(info, cageDetails);
                cageDetails.setSlot(bigStorageCage.getSlot());
                cageDetails.setState(Const.GLASS_STATE_NEW);
                cageDetails.setDeviceId(bigStorageCage.getDeviceId());
                cageDetails.setSequence(0);
                cageDetails.setAngle((int) info.getAngle());
                cageDetails.setGap(glassGap);
                cageDetails.setFilmsId(info.getFilmsId());
                cageDetails.setId(null);
                bigStorageCageDetailsService.save(cageDetails);
            }
            //历史数据入库
            bigStorageCageHistoryTaskService.saveBatch(historyTasks);
            extracted(taskList);
            return;
        }

        Integer temperingOutTargetPosition = sysConfigService.queryConfigValue(ConstSysConfig.VERTICAL_TEMPERING_OUT_TARGET_POSITION);
        if (redisUtil.getCacheObject("temperingSwitch")) {
            //是否允许钢化
@@ -392,17 +457,6 @@
                return;
            }

            BigStorageCageDetails details = bigStorageCageDetailsService.getOne(new LambdaQueryWrapper<BigStorageCageDetails>()
                    .eq(BigStorageCageDetails::getSlot, THROUGH_SLOT)
                    .in(BigStorageCageDetails::getState, Const.GLASS_STATE_IN_ALL).last("limit 1"));
            if (details != null) {
                TemperingGlassInfo temperingGlassInfo = new TemperingGlassInfo();
                BeanUtils.copyProperties(details, temperingGlassInfo);
                temperingGlassInfo.setState(-1);
                temperingGlassInfoService.save(temperingGlassInfo);
                computeOutGlassInfoByVirtualSlot(Arrays.asList(temperingGlassInfo), "big_storage_cage_out_one_task", temperingOutTargetPosition, Const.GLASS_STATE_OUT_ING, Const.BIG_STORAGE_BEFORE_OUT);
                return;
            }
            String temperingEngineerId = redisUtil.getCacheObject("temperingEngineerId");
            if (StringUtils.isNotBlank(temperingEngineerId)) {
                TemperingGlassInfo temperingGlassInfo = temperingGlassInfoService.getOne(new QueryWrapper<TemperingGlassInfo>()
@@ -469,42 +523,44 @@
                log.info("有正在执行的进片任务，结束调度任务");
                return;
            }
            //todo:获取笼内单格已经到齐的玻璃格子信息
            List<BigStorageRelationDTO> virtualList = bigStorageCageDetailsService.queryIsAllNeedDispatchVirtualSlot();
            if (CollectionUtil.isEmpty(virtualList)) {
                log.info("没有需要调度的格子");
//todo:4号获取笼内单格已经到齐的玻璃格子信息
            List<BigStorageRelationDTO> virtualList = bigStorageCageDetailsService.queryIsAllNeedDispatchVirtualSlot(Arrays.asList(4));
            //有：统一往5号笼子送
//            todo:无 4号笼子使用数量是否超过阈值 有 生成调度任务按照组号组序由1开始依次往5号笼子送小片
            //1-3号获取笼内单格已经到齐的玻璃格子信息
            virtualList = bigStorageCageDetailsService.queryIsAllNeedDispatchVirtualSlot(Arrays.asList(1, 2, 3));
            if (CollectionUtil.isNotEmpty(virtualList)) {
                List<BigStorageCageDetails> list = new ArrayList<>();
                loop:
                for (BigStorageRelationDTO dto : virtualList) {
                    List<BigStorageSequenceDTO> sequenceDTOList = bigStorageCageDetailsService.dispatchBigStorageGlassInfo(dto);
                    if (CollectionUtil.isEmpty(sequenceDTOList) || sequenceDTOList.size() == 1) {
                        continue;
                    }
                    int sequence = -1;
                    int targetSlot = -1;
                    for (BigStorageSequenceDTO item : sequenceDTOList) {
                        if (item.getMaxSequence() == sequence - 1) {
                            //生成调度任务
                            int startSlot = item.getSlot();
                            list = bigStorageCageDetailsService.list(new LambdaQueryWrapper<BigStorageCageDetails>()
                                    .eq(BigStorageCageDetails::getState, Const.GLASS_STATE_IN).eq(BigStorageCageDetails::getSlot, startSlot));
                            computeOutGlassInfoByVirtualSlot(list, "big_storage_cage_out_one_task",
                                    targetSlot, Const.GLASS_STATE_SCHEDULE_ING, Const.BIG_STORAGE_BEFORE_DISPATCH);
                            List<Integer> slotList = new ArrayList<>();
                            slotList.add(targetSlot);
                            updateSlotRemainBySlots(slotList);
                            break loop;
                        }
                        sequence = item.getMinSequence();
                        targetSlot = item.getSlot();
                    }
                }
                Date endDate = new Date();
                log.info("大理片笼出片任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime());
                return;
            }
            List<BigStorageCageDetails> list = new ArrayList<>();
            loop:
            for (BigStorageRelationDTO dto : virtualList) {
                List<BigStorageSequenceDTO> sequenceDTOList = bigStorageCageDetailsService.dispatchBigStorageGlassInfo(dto);
                if (CollectionUtil.isEmpty(sequenceDTOList) || sequenceDTOList.size() == 1) {
                    continue;
                }
                int sequence = -1;
                int targetSlot = -1;
                for (BigStorageSequenceDTO item : sequenceDTOList) {
                    if (item.getMaxSequence() == sequence - 1) {
                        //生成调度任务
                        int startSlot = item.getSlot();
                        list = bigStorageCageDetailsService.list(new LambdaQueryWrapper<BigStorageCageDetails>()
                                .eq(BigStorageCageDetails::getState, Const.GLASS_STATE_IN).eq(BigStorageCageDetails::getSlot, startSlot));
                        computeOutGlassInfoByVirtualSlot(list, "big_storage_cage_out_one_task",
                                targetSlot, Const.GLASS_STATE_SCHEDULE_ING, Const.BIG_STORAGE_BEFORE_DISPATCH);
                        List<Integer> slotList = new ArrayList<>();
                        slotList.add(targetSlot);
                        updateSlotRemainBySlots(slotList);
                        break loop;
                    }
                    sequence = item.getMinSequence();
                    targetSlot = item.getSlot();
                }
            }
        }
        Date endDate = new Date();
        log.info("大理片笼出片任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime());
        return;
    }

    @Scheduled(fixedDelay = 1000)
@@ -844,7 +900,8 @@
     * @param <T>
     * @return
     */
    private <T extends BigStorageCageBaseInfo> Boolean computeOutGlassInfoByVirtualSlot(List<T> list, String tableName, int targetSlot, int state, int taskType) {
    private <T extends BigStorageCageBaseInfo> Boolean
    computeOutGlassInfoByVirtualSlot(List<T> list, String tableName, int targetSlot, int state, int taskType) {
        //任务数据:获取车子存放玻璃最大数量,玻璃间隔
        List<T> outGlassList = list;
        if (!THROUGH_SLOT.equals(list.get(0).getSlot())) {
@@ -870,6 +927,41 @@
//            bigStorageCageTaskList.add(new BigStorageCageTask("", 0, 0, 0));
//        }
        //清空任务表数据
        extracted(bigStorageCageTaskList);
        S7DataDLPTwo s7DataDLPTwo;
        List<BigStorageCageHistoryTask> historyList = bigStorageCageTaskList.stream().filter(e -> StringUtils.isNotBlank(e.getGlassId())).map(e -> {
            BigStorageCageHistoryTask history = new BigStorageCageHistoryTask();
            BeanUtils.copyProperties(e, history);
            history.setGlassCount(glassCount);
            history.setTaskType(taskType);
            return history;
        }).collect(Collectors.toList());
        bigStorageCageHistoryTaskService.saveBatch(historyList);

        log.info("将出片玻璃{}玻璃状态改为出片中", glassIds);
        bigStorageCageDetailsService.update(new LambdaUpdateWrapper<BigStorageCageDetails>()
                .set(BigStorageCageDetails::getState, state)
                .set(Const.BIG_STORAGE_BEFORE_DISPATCH.equals(taskType), BigStorageCageBaseInfo::getSlot, targetSlot)
                .ne(BigStorageCageDetails::getState, Const.GLASS_STATE_OUT)
                .in(BigStorageCageDetails::getGlassId, glassIds));
        try {
//            miloService.writeToOpcWord(generateReadWriteEntity("DLP1B.DLP1B.MesReply", 1));
            s7DataDLPTwo = new S7DataDLPTwo();
            s7DataDLPTwo.setMesReply(1);
            s7SerializerDLPTwo.write(s7DataDLPTwo);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return Boolean.TRUE;
    }

    /**
     * 按照任务生成出片任务
     *
     * @param bigStorageCageTaskList
     * @return
     */
    private Boolean extracted(List<BigStorageCageTask> bigStorageCageTaskList) {
        resetOutTask();
        S7DataDLPTwo s7DataDLPTwo = new S7DataDLPTwo();
        for (int i = 0; i < bigStorageCageTaskList.size() && i < 6; i++) {
@@ -912,29 +1004,6 @@
            }
        }
        s7SerializerDLPTwo.write(s7DataDLPTwo);
        List<BigStorageCageHistoryTask> historyList = bigStorageCageTaskList.stream().filter(e -> StringUtils.isNotBlank(e.getGlassId())).map(e -> {
            BigStorageCageHistoryTask history = new BigStorageCageHistoryTask();
            BeanUtils.copyProperties(e, history);
            history.setGlassCount(glassCount);
            history.setTaskType(taskType);
            return history;
        }).collect(Collectors.toList());
        bigStorageCageHistoryTaskService.saveBatch(historyList);

        log.info("将出片玻璃{}玻璃状态改为出片中", glassIds);
        bigStorageCageDetailsService.update(new LambdaUpdateWrapper<BigStorageCageDetails>()
                .set(BigStorageCageDetails::getState, state)
                .set(Const.BIG_STORAGE_BEFORE_DISPATCH.equals(taskType), BigStorageCageBaseInfo::getSlot, targetSlot)
                .ne(BigStorageCageDetails::getState, Const.GLASS_STATE_OUT)
                .in(BigStorageCageDetails::getGlassId, glassIds));
        try {
//            miloService.writeToOpcWord(generateReadWriteEntity("DLP1B.DLP1B.MesReply", 1));
            s7DataDLPTwo = new S7DataDLPTwo();
            s7DataDLPTwo.setMesReply(1);
            s7SerializerDLPTwo.write(s7DataDLPTwo);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return Boolean.TRUE;
    }

@@ -945,7 +1014,8 @@
//     * @param <T>
//     * @return
//     */
    private <T extends BigStorageCageBaseInfo> Boolean computeOutGlassInfo(List<T> list, String tableName, int targetSlot, int state, int taskType) {
    private <T extends BigStorageCageBaseInfo> Boolean computeOutGlassInfo(List<T> list, String tableName,
                                                                           int targetSlot, int state, int taskType) {
        //任务数据:获取车子存放玻璃最大数量,玻璃间隔
        List<BigStorageCageTask> bigStorageCageTaskList = new ArrayList<>();
        //打车剩余尺寸