大理片笼:调度任务完成开发，待测试

zhoushihao

2024-07-29 88955d3be6a16064639f596d4d7987b081a344e2

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

@@ -311,48 +311,49 @@
            }
        }
        //执行内部调度任务
        TemperingLayoutDTO temperingOccupySlot = bigStorageCageDetailsService.queryTemperingOccupySlot();
        if (null != temperingOccupySlot) {
            List<SlotSequenceDTO> slotSequenceList = bigStorageCageDetailsService.queryGlassMaxAndMin(temperingOccupySlot.getEngineerId(), temperingOccupySlot.getTemperingLayoutId());
            for (int i = 0; i < slotSequenceList.size() - 1; i++) {
                SlotSequenceDTO first = slotSequenceList.get(i);
                SlotSequenceDTO second = slotSequenceList.get(i + 1);
                int slotWidth = carWidth - first.getRemainWidth() - glassGap;
                if (first.getMinSequence() == second.getMaxSequence() + 1
                        && second.getRemainWidth() > slotWidth && slotWidth >= 0) {

                    List<BigStorageCageDetails> list = bigStorageCageDetailsService.list(new LambdaQueryWrapper<BigStorageCageDetails>()
                            .eq(BigStorageCageDetails::getSlot, first.getSlot()).eq(BigStorageCageDetails::getState, Const.GLASS_STATE_IN)
                            .orderBy(Boolean.TRUE, sequenceOrder, BigStorageCageDetails::getTemperingFeedSequence));
                    if (CollectionUtils.isNotEmpty(list)) {
                        List<BigStorageCageOutTask> outTasks = new ArrayList<>();
                        int serialNumber = 1;
                        for (BigStorageCageDetails item : list) {
                            outTasks.add(new BigStorageCageOutTask(item.getGlassId(), first.getSlot(), second.getSlot(),
                                    item.getWidth() * 10, item.getHeight() * 10, 1, serialNumber++, Const.BIG_STORAGE_OUT_NEW));
        List<TemperingLayoutDTO> temperingOccupySlotList = bigStorageCageDetailsService.queryTemperingOccupySlot();
        if (CollectionUtils.isNotEmpty(temperingOccupySlotList)) {
            for (TemperingLayoutDTO temperingOccupySlot : temperingOccupySlotList) {
                List<SlotSequenceDTO> slotSequenceList = bigStorageCageDetailsService.queryGlassMaxAndMin(temperingOccupySlot.getEngineerId(), temperingOccupySlot.getTemperingLayoutId());
                for (int i = 0; i < slotSequenceList.size() - 1; i++) {
                    SlotSequenceDTO first = slotSequenceList.get(i);
                    SlotSequenceDTO second = slotSequenceList.get(i + 1);
                    int slotWidth = carWidth - first.getRemainWidth() - glassGap;
                    if (first.getMinSequence() == second.getMaxSequence() + 1
                            && second.getRemainWidth() > slotWidth && slotWidth >= 0) {
                        List<BigStorageCageDetails> list = bigStorageCageDetailsService.list(new LambdaQueryWrapper<BigStorageCageDetails>()
                                .eq(BigStorageCageDetails::getSlot, first.getSlot()).eq(BigStorageCageDetails::getState, Const.GLASS_STATE_IN)
                                .orderBy(Boolean.TRUE, sequenceOrder, BigStorageCageDetails::getTemperingFeedSequence));
                        if (CollectionUtils.isNotEmpty(list)) {
                            List<BigStorageCageOutTask> outTasks = new ArrayList<>();
                            int serialNumber = 1;
                            for (BigStorageCageDetails item : list) {
                                outTasks.add(new BigStorageCageOutTask(item.getGlassId(), first.getSlot(), second.getSlot(),
                                        item.getWidth() * 10, item.getHeight() * 10, 1, serialNumber++, Const.BIG_STORAGE_OUT_NEW));
                            }
                            //新增调度任务
                            bigStorageCageOutTaskService.saveBatch(outTasks);
                            //更新理片笼详情表调度的后的玻璃位置信息：生成任务后先将玻璃格子位置进行调整，玻璃状态改为调度中，新增调度完成任务，处理调度完成后玻璃状态改为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;
                        }
                        //新增调度任务
                        bigStorageCageOutTaskService.saveBatch(outTasks);
                        //更新理片笼详情表调度的后的玻璃位置信息：生成任务后先将玻璃格子位置进行调整，玻璃状态改为调度中，新增调度完成任务，处理调度完成后玻璃状态改为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));
                    }

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

@@ -371,16 +372,16 @@
                    .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<Integer> inSuccessGlassSlot = inSuccessGlass.stream().map(BigStorageCageFeedTask::getTargetSlot).collect(Collectors.toList());
                List<UpdateBigStorageCageDTO> storageCageDTOList = inSuccessGlass.stream().map(e -> {
                    UpdateBigStorageCageDTO storageCageDTO = new UpdateBigStorageCageDTO();
                    BeanUtils.copyProperties(e, storageCageDTO);
                    return storageCageDTO;
                }).collect(Collectors.toList());
                bigStorageCageDetailsService.updateBySlot(storageCageDTOList, Const.GLASS_STATE_IN);
                log.info("4、大理片笼进片状态已完成已完成的玻璃信息id:{}", inSuccessGlassIds);
                log.info("4、大理片笼进片状态已完成已完成的玻璃信息id:{}", inSuccessGlass);
                //更新理片笼玻璃尺寸
                updateSlotRemain(inSuccessGlassIds, Boolean.TRUE);
                updateSlotRemainBySlots(inSuccessGlassSlot);
                log.info("5、大理片笼进片目标格子尺寸更新完成");
            }

@@ -412,10 +413,47 @@
                    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);
                List<Integer> outSuccessSlotList = outSuccessGlass.stream().map(BigStorageCageOutTask::getStartSlot).collect(Collectors.toList());
                log.info("4、大理片笼出片状态已完成已完成的玻璃信息id:{}", outSuccessGlass);
                //更新理片笼玻璃尺寸
                updateSlotRemain(outSuccessGlassIds, Boolean.FALSE);
                updateSlotRemainBySlots(outSuccessSlotList);
                log.info("5、大理片笼进片目标格子尺寸更新完成");
            }
        }
        Date endDate = new Date();
        log.info("end:大理片笼出片完成后更新大理片笼数据任务结束时间：{}，共耗时：{}ms,结束任务", endDate, endDate.getTime() - startDate.getTime());
        return;

    }

    @Scheduled(fixedDelay = 300)
    public void updateScheduleGlassStateTask() {
        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_SCHEDULE_ING));
        if (CollectionUtils.isNotEmpty(list)) {
            log.info("2、获取所有正在出片的玻璃信息id:{}", list);
            List<String> glassIds = list.stream().map(String::valueOf).collect(Collectors.toList());
            List<BigStorageCageOutTask> scheduleSuccessGlass = bigStorageCageOutTaskService.list(new LambdaQueryWrapper<BigStorageCageOutTask>()
                    .in(BigStorageCageOutTask::getGlassId, glassIds).eq(BigStorageCageOutTask::getTaskState, Const.BIG_STORAGE_OUT_SUCCESS)
                    .notIn(BigStorageCageOutTask::getEndSlot, Const.TEMPERING_OUT_TARGET_POSITION, Const.ARTIFICIAL_OUT_TARGET_POSITION));
            if (CollectionUtils.isNotEmpty(scheduleSuccessGlass)) {
                log.info("3、获取调度已完成的玻璃信息id:{}", scheduleSuccessGlass);
                List<UpdateBigStorageCageDTO> storageCageDTOList = scheduleSuccessGlass.stream().map(e -> {
                    UpdateBigStorageCageDTO storageCageDTO = new UpdateBigStorageCageDTO();
                    storageCageDTO.setGlassId(e.getGlassId());
                    storageCageDTO.setTargetSlot(e.getEndSlot());
                    return storageCageDTO;
                }).collect(Collectors.toList());
                bigStorageCageDetailsService.updateBySlot(storageCageDTOList, Const.GLASS_STATE_IN);
                List<String> scheduleSuccessGlassIds = scheduleSuccessGlass.stream().map(BigStorageCageOutTask::getGlassId).collect(Collectors.toList());
                log.info("4、大理片笼出片状态已完成已完成的玻璃信息id:{}", scheduleSuccessGlassIds);
                //更新理片笼玻璃尺寸
                List<Integer> slotList = scheduleSuccessGlass.stream().map(BigStorageCageOutTask::getStartSlot).distinct().collect(Collectors.toList());
                slotList.addAll(scheduleSuccessGlass.stream().map(BigStorageCageOutTask::getEndSlot).distinct().collect(Collectors.toList()));
                updateSlotRemainBySlots(slotList);
                log.info("5、大理片笼进片目标格子尺寸更新完成");
            }
        }
@@ -716,47 +754,28 @@
        return Boolean.TRUE;
    }

    /**
     * 更新笼子内格子的剩余尺寸
     *
     * @param taskGlassIds 本次任务出去的玻璃ids
     * @param flag         是否进出片 true 进片  false 出片
     */
    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());
    public void updateSlotRemainBySlots(List<Integer> slotList) {
        //获取格子内所有的玻璃信息
        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()))
        Map<Integer, Double> slotRemainMap = new HashMap<>();
        //是否存在有格子非空的玻璃
        if (CollectionUtils.isNotEmpty(inSlotGlassList)) {
            //存在  将格子内的玻璃分别进行更新
            slotRemainMap = inSlotGlassList.stream()
                    .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));
            });
        }
        //只更新进笼完成的状态，如果进笼完成，格子内必定有玻璃，不存在出片后格子内没有玻璃的情况，所有格子尺寸重置，只能存在于出片任务
        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));
            }
        //过滤不存在玻璃的格子 将宽度重置为原始宽度5000
        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) {