1、提交中控模块 2、修改大理片笼进出片交互bug

zhoushihao

2024-12-02 3345225e1a1c5c9665a948ae612a677ae284431b

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

@@ -17,6 +17,7 @@
import com.mes.bigstorage.service.BigStorageCageDetailsService;
import com.mes.bigstorage.service.BigStorageCageService;
import com.mes.bigstorage.service.BigStorageGlassInfoService;
import com.mes.bigstorage.service.BigStorageGlassRelationInfoService;
import com.mes.bigstoragecagetask.entity.BigStorageCageHistoryTask;
import com.mes.bigstoragecagetask.entity.BigStorageCageTask;
import com.mes.bigstoragecagetask.service.BigStorageCageHistoryTaskService;
@@ -25,6 +26,8 @@
import com.mes.common.config.Const;
import com.mes.damage.entity.Damage;
import com.mes.damage.service.DamageService;
import com.mes.edgglasstask.entity.EdgGlassTaskInfo;
import com.mes.edgglasstask.service.EdgGlassTaskInfoService;
import com.mes.glassinfo.entity.GlassInfo;
import com.mes.glassinfo.service.GlassInfoService;
import com.mes.temperingglass.entity.TemperingGlassInfo;
@@ -57,6 +60,8 @@
    @Resource
    private GlassInfoService glassInfoService;
    @Resource
    private BigStorageGlassRelationInfoService bigStorageGlassRelationInfoService;
    @Resource
    private BigStorageCageService bigStorageCageService;
    @Resource
    private BigStorageCageHistoryTaskService bigStorageCageHistoryTaskService;
@@ -64,6 +69,8 @@
    private BigStorageCageTaskService bigStorageCageTaskService;
    @Resource
    private BigStorageGlassInfoService bigStorageGlassInfoService;
    @Resource
    private EdgGlassTaskInfoService edgGlassTaskInfoService;

    @Autowired(required = false)
    MiloService miloService;
@@ -85,6 +92,10 @@

    @Value("${mes.sequence.order}")
    private boolean sequenceOrder;
    @Value("${mes.temperingOutTargetPosition}")
    private Integer temperingOutTargetPosition;
    @Value("${mes.artificialOutTargetPosition}")
    private Integer artificialOutTargetPosition;


    @Scheduled(fixedDelay = 1000)
@@ -104,13 +115,25 @@
            log.info("有正在执行的任务，结束进片任务");
            return;
        }
        //获取进片任务表
        List<BigStorageCageTask> inTaskList = bigStorageCageTaskService.queryTaskMessage("big_storage_cage_in_one_task");
        //获取进片任务信息
        List<BigStorageCageTask> inTaskList = new ArrayList();
        ReadWriteEntity fromOpcUa = miloService.readFromOpcUa("DLP1A.DLP1A.FROM1");
        List<String> glassIdList = new ArrayList<>();
        for (int i = 1; i <= 6; i++) {
            ReadWriteEntity requestWord = miloService.readFromOpcUa("DLP1A.DLP1A.DI" + i);
            if (null != requestWord.getValue()) {
                BigStorageCageTask task = new BigStorageCageTask();
                task.setGlassId(requestWord.getValue() + "");
                task.setStartSlot(Integer.parseInt(fromOpcUa.getValue() + ""));
                inTaskList.add(task);
                glassIdList.add(requestWord.getValue() + "");
                continue;
            }
        }
        if (CollectionUtil.isEmpty(inTaskList)) {
            log.info("当前大车无进片玻璃，结束进片任务");
            return;
        }

        List<String> glassIdList = inTaskList.stream().map(BigStorageCageTask::getGlassId).collect(Collectors.toList());
        log.info("获取任务的玻璃id：{}", glassIdList);
        Map<String, Long> glassCountMap = glassIdList.stream().collect(Collectors.groupingBy(e -> e, Collectors.counting()));
        for (Map.Entry<String, Long> entry : glassCountMap.entrySet()) {
@@ -129,13 +152,20 @@
        }
        List<GlassInfo> glassInfoList = glassInfoService.list(new LambdaQueryWrapper<GlassInfo>().in(GlassInfo::getGlassId, glassIdList));

        if (glassInfoList.size() != inTaskList.size()) {
            log.info("进片任务数量{}与玻璃数量{}不匹配，结束本次进片", inTaskList.size(), glassInfoList.size());
            //todo:向plc发送报警
            return;
        }
        //修改磨边对列表的玻璃状态
        edgGlassTaskInfoService.update(new LambdaUpdateWrapper<EdgGlassTaskInfo>()
                .set(EdgGlassTaskInfo::getState, Const.EDG_GLASS_SUCCESS).in(EdgGlassTaskInfo::getGlassId, glassIdList));
        Map<String, List<GlassInfo>> glassListMap = glassInfoList.stream().collect(Collectors.groupingBy(GlassInfo::getGlassId));

        //计算目标格子
        List<BigStorageCageHistoryTask> historyTasks = new ArrayList<>();
        for (BigStorageCageTask task : inTaskList) {
            GlassInfo info = glassListMap.get(task.getGlassId()).get(0);
            BigStorageDTO bigStorageDTO = bigStorageGlassInfoService.queryBigStorageTargetSlot(info.getGlassId());
            BigStorageDTO bigStorageDTO = bigStorageGlassInfoService.queryBigStorageTargetSlot(info.getEngineerId(), info.getTemperingLayoutId(), info.getTemperingFeedSequence());
            //获取目标格子信息
//            BigStorageDTO bigStorageDTO = bigStorageCageDetailsService.queryTargetSlotByTempering(info);
//            临时更新格子的剩余尺寸：防止相邻玻璃进同一格子造成剩余尺寸不足，玻璃越界的情况，任务完成后再次更新大理片笼表剩余宽度（按照笼内玻璃数量更新大理片笼剩余尺寸）
@@ -165,7 +195,12 @@
        //历史数据入库
        bigStorageCageHistoryTaskService.saveBatch(historyTasks);
        //向opc发送启动信号
        miloService.writeToOpcWord(generateReadWriteEntity("DLP1A.DLP1A.MesReply", 1));
        List<ReadWriteEntity> list = new ArrayList<>();
        for (int i = 1; i <= inTaskList.size(); i++) {
            list.add(generateReadWriteEntity("DLP1A.DLP1A.TO" + i, inTaskList.get(i - 1).getTargetSlot()));
        }
        list.add(generateReadWriteEntity("DLP1A.DLP1A.MesReply", 1));
        miloService.writeToOpcWord(list);
    }

    @Scheduled(fixedDelay = 1000)
@@ -187,29 +222,29 @@
            log.info("有正在执行的出片任务，结束本次出片任务");
            return;
        }
        //todo:是否允许钢化
        if (redisUtil.getCacheObject("temperingSwitch")) {
            //是否有正在钢化的玻璃:钢化小片表关联历史任务表，筛选未出笼的玻璃信息
        //是否允许钢化
        //是否有正在钢化的玻璃:钢化小片表关联历史任务表，筛选未出笼的玻璃信息
//            获取当前钢化任务未完成出片的玻璃信息
            List<TemperingGlassInfo> unFinishTemperingGlassInfoList = temperingGlassInfoService.list(new LambdaQueryWrapper<TemperingGlassInfo>().eq(TemperingGlassInfo::getState, Const.TEMPERING_NEW));
            if (CollectionUtil.isNotEmpty(unFinishTemperingGlassInfoList)) {
                List<String> glassIdList = unFinishTemperingGlassInfoList.stream().map(TemperingGlassInfo::getGlassId).collect(Collectors.toList());
                List<BigStorageCageHistoryTask> historyTaskList = bigStorageCageHistoryTaskService.list(new LambdaQueryWrapper<BigStorageCageHistoryTask>()
                        .eq(BigStorageCageHistoryTask::getTaskType, Const.BIG_STORAGE_BEFORE_OUT)
                        .in(BigStorageCageHistoryTask::getGlassId, glassIdList));
                List<TemperingGlassInfo> temperingGlassList = unFinishTemperingGlassInfoList;
                if (CollectionUtil.isNotEmpty(historyTaskList)) {
                    List<String> taskGlassList = historyTaskList.stream().map(BigStorageCageHistoryTask::getGlassId).collect(Collectors.toList());
                    temperingGlassList = unFinishTemperingGlassInfoList.stream().filter(e -> !taskGlassList.contains(e.getGlassId())).collect(Collectors.toList());
                }
                if (CollectionUtil.isNotEmpty(temperingGlassList)) {
                    log.info("有正在出片的钢化任务");
                    computeOutGlassInfo(temperingGlassList, "big_storage_cage_out_one_task", Const.TEMPERING_OUT_TARGET_POSITION, Const.GLASS_STATE_OUT_ING, Const.BIG_STORAGE_BEFORE_OUT);
                    Date endDate = new Date();
                    log.info("大理片笼出片任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime());
                    return;
                }
            }
        List<TemperingGlassInfo> unFinishTemperingGlassInfoList = temperingGlassInfoService.list(new LambdaQueryWrapper<TemperingGlassInfo>().eq(TemperingGlassInfo::getState, Const.TEMPERING_NEW));
        if (CollectionUtil.isNotEmpty(unFinishTemperingGlassInfoList)) {
//            List<String> glassIdList = unFinishTemperingGlassInfoList.stream().map(TemperingGlassInfo::getGlassId).collect(Collectors.toList());
//            List<BigStorageCageHistoryTask> historyTaskList = bigStorageCageHistoryTaskService.list(new LambdaQueryWrapper<BigStorageCageHistoryTask>()
//                    .eq(BigStorageCageHistoryTask::getTaskType, Const.BIG_STORAGE_BEFORE_OUT)
//                    .in(BigStorageCageHistoryTask::getGlassId, glassIdList));
//            List<TemperingGlassInfo> temperingGlassList = unFinishTemperingGlassInfoList;
//            if (CollectionUtil.isNotEmpty(historyTaskList)) {
//                List<String> taskGlassList = historyTaskList.stream().map(BigStorageCageHistoryTask::getGlassId).collect(Collectors.toList());
//                temperingGlassList = unFinishTemperingGlassInfoList.stream().filter(e -> !taskGlassList.contains(e.getGlassId())).collect(Collectors.toList());
//            }
//            if (CollectionUtil.isNotEmpty(unFinishTemperingGlassInfoList)) {
            log.info("有正在出片的钢化任务");
            computeOutGlassInfoByVirtualSlot(unFinishTemperingGlassInfoList, "big_storage_cage_out_one_task", temperingOutTargetPosition, Const.GLASS_STATE_OUT_ING, Const.BIG_STORAGE_BEFORE_OUT);
            Date endDate = new Date();
            log.info("大理片笼出片任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime());
            return;
        }

        if (redisUtil.getCacheObject("temperingSwitch")) {
            //钢化优先：获取理片笼  玻璃小片  破损表 数量   判断笼内版图是否到齐
            List<TemperingLayoutDTO> temperingLayoutDTOList = bigStorageCageDetailsService.temperingIsAll();
            if (CollectionUtil.isNotEmpty(temperingLayoutDTOList)) {
@@ -228,7 +263,7 @@
                            .orderBy(Boolean.TRUE, sequenceOrder, GlassInfo::getTemperingFeedSequence));
                    if (CollectionUtil.isNotEmpty(temperingGlassInfos)) {
                        temperingGlassInfoService.saveBatch(temperingGlassInfos);
                        computeOutGlassInfo(temperingGlassInfos, "big_storage_cage_out_one_task", Const.TEMPERING_OUT_TARGET_POSITION, Const.GLASS_STATE_OUT_ING, Const.BIG_STORAGE_BEFORE_OUT);
                        computeOutGlassInfoByVirtualSlot(temperingGlassInfos, "big_storage_cage_out_one_task", temperingOutTargetPosition, Const.GLASS_STATE_OUT_ING, Const.BIG_STORAGE_BEFORE_OUT);
                        Date endDate = new Date();
                        log.info("大理片笼出片任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime());
                        return;
@@ -241,9 +276,9 @@
        List<BigStorageCageDetails> artificialList = bigStorageCageDetailsService.list(new LambdaQueryWrapper<BigStorageCageDetails>()
                .eq(BigStorageCageDetails::getState, Const.GLASS_STATE_ARTIFICIAL)
                .orderByAsc(BigStorageCageDetails::getSlot)
                .orderByAsc(BigStorageCageDetails::getId));
                .orderByAsc(BigStorageCageDetails::getId).last("limit " + outCarMaxSize));
        if (CollectionUtil.isNotEmpty(artificialList)) {
            computeOutGlassInfo(artificialList, "big_storage_cage_out_one_task", Const.ARTIFICIAL_OUT_TARGET_POSITION, Const.GLASS_STATE_OUT_ING, Const.BIG_STORAGE_BEFORE_OUT);
            computeOutGlassInfoByVirtualSlot(artificialList, "big_storage_cage_out_one_task", artificialOutTargetPosition, Const.GLASS_STATE_OUT_ING, Const.BIG_STORAGE_BEFORE_OUT);
            Date endDate = new Date();
            log.info("大理片笼出片任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime());
            return;
@@ -257,6 +292,7 @@
                return;
            }
            List<BigStorageCageDetails> list = new ArrayList<>();
            loop:
            for (BigStorageRelationDTO dto : virtualList) {
                List<BigStorageSequenceDTO> sequenceDTOList = bigStorageCageDetailsService.dispatchBigStorageGlassInfo(dto);
                if (CollectionUtil.isEmpty(sequenceDTOList) || sequenceDTOList.size() == 1) {
@@ -270,11 +306,11 @@
                        int targetSlot = item.getSlot();
                        list = bigStorageCageDetailsService.list(new LambdaQueryWrapper<BigStorageCageDetails>()
                                .eq(BigStorageCageDetails::getState, Const.GLASS_STATE_IN).eq(BigStorageCageDetails::getSlot, startSlot));
                        computeOutGlassInfo(list, "big_storage_cage_out_one_task", targetSlot, Const.GLASS_STATE_SCHEDULE_ING, Const.BIG_STORAGE_BEFORE_DISPATCH);
                        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;
                        break loop;
                    }
                    sequence = item.getMaxSequence();
                    startSlot = item.getSlot();
@@ -294,7 +330,32 @@
            return;
        }
        //获取进片任务表
        List<BigStorageCageTask> inTaskList = bigStorageCageTaskService.queryTaskMessage("big_storage_cage_in_one_task");
//        List<BigStorageCageTask> inTaskList = bigStorageCageTaskService.queryTaskMessage("big_storage_cage_in_one_task");
        List<BigStorageCageTask> inTaskList = new ArrayList();

        List<String> glassIdList = new ArrayList<>();
        ReadWriteEntity toWord = miloService.readFromOpcUa("DLP1A.DLP1A.TO1");
        if ("0".equals(toWord.getValue() + "")) {
            log.info("完成任务已执行，结束本次完成进片任务");
            return;
        }
        for (int i = 1; i <= 6; i++) {
            ReadWriteEntity requestWord = miloService.readFromOpcUa("DLP1A.DLP1A.DI" + i);
            ReadWriteEntity statetWord = miloService.readFromOpcUa("DLP1A.DLP1A.STATE" + i);
            ReadWriteEntity toOpcUa = miloService.readFromOpcUa("DLP1A.DLP1A.TO" + i);
            ReadWriteEntity fromOpcUa = miloService.readFromOpcUa("DLP1A.DLP1A.FROM" + i);

            if (null != requestWord.getValue()) {
                BigStorageCageTask task = new BigStorageCageTask();
                task.setGlassId(requestWord.getValue() + "");
                task.setTargetSlot(Integer.parseInt(toOpcUa.getValue() + ""));
                task.setTaskState(Integer.parseInt(statetWord.getValue() + ""));
                task.setStartSlot(Integer.parseInt(fromOpcUa.getValue() + ""));
                inTaskList.add(task);
                glassIdList.add(requestWord.getValue() + "");
                continue;
            }
        }
        if (CollectionUtil.isEmpty(inTaskList)) {
            log.info("当前大车无进片玻璃，结束完成进片任务");
            return;
@@ -341,7 +402,13 @@
        }
        //清空启动状态
        //向opc发送启动信号
        miloService.writeToOpcWord(generateReadWriteEntity("DLP1A.DLP1A.MesReply", 0));
        //向opc发送启动信号
        List<ReadWriteEntity> list = new ArrayList<>();
        for (int i = 1; i <= 6; i++) {
            list.add(generateReadWriteEntity("DLP1A.DLP1A.TO" + i, 0));
        }
        list.add(generateReadWriteEntity("DLP1A.DLP1A.MesReply", 0));
        miloService.writeToOpcWord(list);
    }

    @Scheduled(fixedDelay = 1000)
@@ -380,7 +447,10 @@
                if (finalTaskType.equals(Const.BIG_STORAGE_BEFORE_OUT)) {
                    outSuccessGlassSlot = v.stream().map(BigStorageCageTask::getStartSlot).collect(Collectors.toList());
                } else {
                    outSuccessGlassSlot = v.stream().map(BigStorageCageTask::getTargetSlot).collect(Collectors.toList());
                    List<Integer> targetSuccessGlassSlot = v.stream().map(BigStorageCageTask::getTargetSlot).collect(Collectors.toList());
                    List<Integer> startoutSuccessGlassSlot = v.stream().map(BigStorageCageTask::getStartSlot).collect(Collectors.toList());
                    outSuccessGlassSlot.addAll(targetSuccessGlassSlot);
                    outSuccessGlassSlot.addAll(startoutSuccessGlassSlot);
                }
                List<UpdateBigStorageCageDTO> storageCageDTOList = v.stream().map(e -> {
                    UpdateBigStorageCageDTO storageCageDTO = new UpdateBigStorageCageDTO();
@@ -512,6 +582,7 @@
            List<String> glassList = noDealTaskList.stream().map(BigStorageCageTask::getGlassId).collect(Collectors.toList());
            bigStorageCageDetailsService.update(new LambdaUpdateWrapper<BigStorageCageDetails>()
                    .set(BigStorageCageDetails::getState, Const.GLASS_STATE_IN)
                    .ne(BigStorageCageDetails::getState, Const.GLASS_STATE_OUT)
                    .in(BigStorageCageDetails::getGlassId, glassList));

        } else {
@@ -520,6 +591,7 @@
                bigStorageCageDetailsService.update(new LambdaUpdateWrapper<BigStorageCageDetails>()
                        .set(BigStorageCageDetails::getSlot, item.getStartSlot())
                        .set(BigStorageCageDetails::getState, Const.GLASS_STATE_IN)
                        .ne(BigStorageCageDetails::getState, Const.GLASS_STATE_OUT)
                        .eq(BigStorageCageDetails::getGlassId, item.getGlassId()));
            }
        }
@@ -541,6 +613,55 @@
     * @param <T>
     * @return
     */
    private <T extends BigStorageCageBaseInfo> Boolean computeOutGlassInfoByVirtualSlot(List<T> list, String tableName, int targetSlot, int state, int taskType) {
        //任务数据:获取车子存放玻璃最大数量,玻璃间隔
        List<String> glassIdList = bigStorageGlassRelationInfoService.queryNeedOutGlassId(
                list.get(0).getEngineerId(), list.get(0).getTemperingLayoutId(), list.get(0).getTemperingFeedSequence());
        List<T> outGlassList = list.stream().filter(e -> glassIdList.contains(e.getGlassId())).collect(Collectors.toList());
        Assert.isFalse(CollectionUtil.isEmpty(outGlassList), "未获取出片数据，结束出片任务");
        log.info("获取出片任务数据{}条，执行保存", outGlassList.size());
        List<BigStorageCageTask> bigStorageCageTaskList = outGlassList.stream()
                .map(e -> new BigStorageCageTask(e.getGlassId(), e.getSlot(), targetSlot, 0)).collect(Collectors.toList());

        List<String> glassIds = bigStorageCageTaskList.stream().map(BigStorageCageTask::getGlassId).collect(Collectors.toList());
        int glassCount = bigStorageCageTaskList.size();
        //生成出片任务条数不足6补全
        while (bigStorageCageTaskList.size() < 6) {
            bigStorageCageTaskList.add(new BigStorageCageTask("", 0, 0, 0));
        }
        //清空任务表数据
        bigStorageCageTaskService.removeAll("big_storage_cage_out_one_task");
        bigStorageCageTaskService.saveTaskMessage(tableName, bigStorageCageTaskList);
        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.RAW_GLASS_TASK_TYPE_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));
        } catch (Exception e) {
            e.printStackTrace();
        }
        return Boolean.TRUE;
    }

    //    /**
//     * 出片一次仅生成一车玻璃
//     *
//     * @param list
//     * @param <T>
//     * @return
//     */
    private <T extends BigStorageCageBaseInfo> Boolean computeOutGlassInfo(List<T> list, String tableName, int targetSlot, int state, int taskType) {
        //任务数据:获取车子存放玻璃最大数量,玻璃间隔
        List<BigStorageCageTask> bigStorageCageTaskList = new ArrayList<>();
@@ -578,6 +699,7 @@
        log.info("将出片玻璃{}玻璃状态改为出片中", glassIds);
        bigStorageCageDetailsService.update(new LambdaUpdateWrapper<BigStorageCageDetails>()
                .set(BigStorageCageDetails::getState, state)
                .ne(BigStorageCageDetails::getState, Const.GLASS_STATE_OUT)
                .set(Const.GLASS_STATE_SCHEDULE_ING.equals(state), BigStorageCageBaseInfo::getSlot, targetSlot)
                .in(BigStorageCageDetails::getGlassId, glassIds));
        try {