义乌项目
blame | 历史 | 补丁 | 提交 | 提交对比 | ignore whitespace
ZengTao
2025-05-26 fcb8b8cc392b146aa11bbaab9e497f7f13f29d44 
 hangzhoumesParent/moduleService/CacheVerticalGlassModule/src/main/java/com/mes/job/OpcPlcStorageCageNewTask.java


@@ -24,12 +24,14 @@


import com.mes.bigstoragecagetask.service.BigStorageCageTaskService;


import com.mes.bigstoragetask.entity.UpdateBigStorageCageDTO;


import com.mes.common.config.Const;


import com.mes.common.config.ConstSysConfig;


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.sysconfig.service.SysConfigService;


import com.mes.temperingglass.entity.TemperingGlassInfo;


import com.mes.temperingglass.service.TemperingGlassInfoService;


import com.mes.utils.RedisUtil;


@@ -37,7 +39,6 @@


import org.apache.commons.lang.StringUtils;


import org.springframework.beans.BeanUtils;


import org.springframework.beans.factory.annotation.Autowired;


import org.springframework.beans.factory.annotation.Value;


import org.springframework.scheduling.annotation.Scheduled;


import org.springframework.stereotype.Component;




@@ -76,25 +77,15 @@


    MiloService miloService;




    @Resource


    SysConfigService sysConfigService;




    /**


     * 直通格子


     */


    private static final Integer THROUGH_SLOT = 920;




    @Resource


    private RedisUtil redisUtil;




    @Value("${mes.slotWidth}")


    private Integer slotWidth;




    @Value("${mes.glassGap}")


    private Integer glassGap;




    @Value("${mes.carWidth}")


    private Integer carWidth;




    @Value("${mes.outCarMaxSize}")


    private Integer outCarMaxSize;




    @Value("${mes.temperingOutTargetPosition}")


    private Integer temperingOutTargetPosition;


    @Value("${mes.artificialOutTargetPosition}")


    private Integer artificialOutTargetPosition;






//    @Scheduled(fixedDelay = 1000)


    public void inBigStorageTask() throws Exception {


@@ -133,45 +124,118 @@


            return;


        }


        log.info("获取任务的玻璃id：{}", glassIdList);


        ReadWriteEntity countEntity = miloService.readFromOpcUa("DLP1A.DLP1A.glassCount");


        if (null == countEntity.getValue() || Integer.parseInt(countEntity.getValue() + "") != glassIdList.size()) {


            log.info("当前大车进片玻璃数量{}与mes读取到的数量{}不匹配，结束进片任务", countEntity.getValue(), glassIdList.size());


            //向plc发送报警:当前大车进片玻璃数量与mes读取到的数量不匹配


            miloService.writeToOpcWord(generateReadWriteEntity("DLP1A.DLP1A.alarmSignal", 1));


            return;


        }


        Map<String, Long> glassCountMap = glassIdList.stream().collect(Collectors.groupingBy(e -> e, Collectors.counting()));


        for (Map.Entry<String, Long> entry : glassCountMap.entrySet()) {


            if (entry.getValue() > 1) {


                log.info("进片玻璃{}存在相同，结束本次任务", entry.getKey());


                //todo:向plc发送报警


                //向plc发送报警:同一车进片玻璃存在相同


                miloService.writeToOpcWord(generateReadWriteEntity("DLP1A.DLP1A.alarmSignal", 2));


                return;


            }


        }


        List<BigStorageCageDetails> detailsList = bigStorageCageDetailsService.list(new LambdaQueryWrapper<BigStorageCageDetails>().in(BigStorageCageDetails::getGlassId, glassIdList)


                .in(BigStorageCageDetails::getState, Const.GLASS_STATE_IN_ALL));


                .in(BigStorageCageDetails::getState, Const.GLASS_STATE_IN_ALL_ZERO));


        if (CollectionUtil.isNotEmpty(detailsList)) {


            log.info("理片笼存在相同的进片玻璃{}，结束本次任务", detailsList);


            //todo:向plc发送报警


            //向plc发送报警:理片笼存在相同的进片玻璃


            miloService.writeToOpcWord(generateReadWriteEntity("DLP1A.DLP1A.alarmSignal", 4));


            return;


        }


        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发送报警


            //向plc发送报警:进片任务数量与系统查询到的玻璃数量不匹配


            miloService.writeToOpcWord(generateReadWriteEntity("DLP1A.DLP1A.alarmSignal", 8));


            return;


        }


        Integer glassGap = sysConfigService.queryConfigValue(ConstSysConfig.VERTICAL_GLASS_GAP);


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


            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)


                        .le(BigStorageCage::getMinThickness, entry.getKey())


                        .ge(BigStorageCage::getMaxThickness, entry.getKey()));


                if (count < entry.getValue()) {


                    log.info("笼内格子剩余数量不足，结束本次进片");


                    //向plc发送报警:笼内格子剩余数量不足


                    miloService.writeToOpcWord(generateReadWriteEntity("DLP1A.DLP1A.alarmSignal", 16));


                    return;


                }


            }


        }


        //超大尺寸


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


            if (count > 0) {


                log.info("直通片台存在玻璃，结束本次进片");


                //向plc发送报警:直通片台存在玻璃，无法继续直通


                miloService.writeToOpcWord(generateReadWriteEntity("DLP1A.DLP1A.alarmSignal", 64));


                return;


            }


        }




        //修改磨边对列表的玻璃状态


        edgGlassTaskInfoService.update(new LambdaUpdateWrapper<EdgGlassTaskInfo>()


                .set(EdgGlassTaskInfo::getState, Const.EDG_GLASS_SUCCESS).in(EdgGlassTaskInfo::getGlassId, glassIdList));


        //报工


        for (String glass : glassIdList) {


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


        for (BigStorageCageTask task : inTaskList) {


            GlassInfo info = glassListMap.get(task.getGlassId()).get(0);


            BigStorageDTO bigStorageDTO = bigStorageGlassInfoService.queryBigStorageTargetSlot(info.getEngineerId(), info.getTemperingLayoutId(), info.getTemperingFeedSequence());


            //获取目标格子信息


        //超大尺寸与正常尺寸玻璃计算方式不一样


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


                //获取目标格子信息


//            BigStorageDTO bigStorageDTO = bigStorageCageDetailsService.queryTargetSlotByTempering(info);


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


            bigStorageCageService.update(new LambdaUpdateWrapper<BigStorageCage>()


                    .set(BigStorageCage::getRemainWidth, bigStorageDTO.getWidth() - Math.max(info.getWidth(), info.getHeight()) - glassGap)


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


            task.setTargetSlot(bigStorageDTO.getSlot());


            task.setGlassId(info.getGlassId());


                bigStorageCageService.update(new LambdaUpdateWrapper<BigStorageCage>()


                        .set(BigStorageCage::getRemainWidth, bigStorageDTO.getWidth() - Math.max(info.getWidth(), info.getHeight()) - glassGap)


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


                task.setTargetSlot(bigStorageDTO.getSlot());


                task.setGlassId(info.getGlassId());


                bigStorageCageTaskService.updateTaskMessage("big_storage_cage_in_one_task", task);


                //存放历史任务


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


                BigStorageCageDetails cageDetails = new BigStorageCageDetails();


                BeanUtils.copyProperties(info, cageDetails);


                cageDetails.setSlot(bigStorageDTO.getSlot());


                cageDetails.setState(Const.GLASS_STATE_NEW);


                cageDetails.setDeviceId(bigStorageDTO.getDeviceId());


                cageDetails.setSequence(bigStorageDTO.getSlotSequence());


                cageDetails.setAngle((int) info.getAngle());


                cageDetails.setGap(glassGap);


                cageDetails.setFilmsId(info.getFilmsid());


                cageDetails.setId(null);


                bigStorageCageDetailsService.save(cageDetails);


            }


        } else {


            BigStorageCageTask task = inTaskList.get(0);


            task.setTargetSlot(THROUGH_SLOT);


            bigStorageCageTaskService.updateTaskMessage("big_storage_cage_in_one_task", task);


            //存放历史任务


            BigStorageCageHistoryTask historyTask = new BigStorageCageHistoryTask();


@@ -180,13 +244,16 @@


            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(bigStorageDTO.getSlot());


            cageDetails.setSlot(THROUGH_SLOT);


            cageDetails.setState(Const.GLASS_STATE_NEW);


            cageDetails.setDeviceId(bigStorageDTO.getDeviceId());


            cageDetails.setSequence(bigStorageDTO.getSlotSequence());


            cageDetails.setDeviceId(0);


            cageDetails.setSequence(0);


            cageDetails.setGap(glassGap);


            cageDetails.setAngle((int) info.getAngle());


            cageDetails.setFilmsId(info.getFilmsid());


            cageDetails.setId(null);


            bigStorageCageDetailsService.save(cageDetails);


        }


@@ -223,23 +290,27 @@


        //是否允许钢化


        //是否有正在钢化的玻璃:钢化小片表关联历史任务表，筛选未出笼的玻璃信息


//            获取当前钢化任务未完成出片的玻璃信息




        Integer temperingOutTargetPosition = sysConfigService.queryConfigValue(ConstSysConfig.VERTICAL_TEMPERING_OUT_TARGET_POSITION);


        List<TemperingGlassInfo> unFinishTemperingGlassInfoList = temperingGlassInfoService.list(new LambdaQueryWrapper<TemperingGlassInfo>()


                .eq(TemperingGlassInfo::getState, Const.TEMPERING_NEW).orderByAsc(TemperingGlassInfo::getTemperingFeedSequence));


                .eq(TemperingGlassInfo::getState, Const.TEMPERING_NEW).orderByAsc(TemperingGlassInfo::getTemperingLayoutId).orderByAsc(TemperingGlassInfo::getTemperingFeedSequence));


        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;


        }




        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;


        }




@@ -252,9 +323,9 @@


                for (TemperingLayoutDTO item : temperingLayoutDTOList) {


//                    if (item.getEngineerId().equals(redisUtil.getCacheObject("temperingengineerId"))) {


                    List<TemperingGlassInfo> temperingGlassInfos = glassInfoService.selectJoinList(TemperingGlassInfo.class, JoinWrappers.lambda(GlassInfo.class)


                            .selectAll(GlassInfo.class)


                            .select("-1 as state")


                            .selectAs(BigStorageCageDetails::getSlot, TemperingGlassInfo::getSlot)


                            .select("-1 as state,t.filmsid as films_id,t.glass_id,t.flow_card_id,t.glass_type,t.width,t.height" +


                                    ",t.thickness,t.ishorizontal,t.tempering_layout_id,t.tempering_feed_sequence,t.x_coordinate,t.y_coordinate," +


                                    "t.angle,t1.slot,t.engineer_id")


                            .innerJoin(BigStorageCageDetails.class, BigStorageCageDetails::getGlassId, GlassInfo::getGlassId)


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


                            .eq(GlassInfo::getTemperingLayoutId, item.getTemperingLayoutId())


@@ -272,6 +343,8 @@


            }


        }


        //是否有人工下片任务   有直接出


        Integer artificialOutTargetPosition = sysConfigService.queryConfigValue(ConstSysConfig.VERTICAL_ARTIFICIAL_OUT_TARGET_POSITION);


        Integer outCarMaxSize = sysConfigService.queryConfigValue(ConstSysConfig.VERTICAL_OUT_CAR_SIZE);


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


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


                .orderByAsc(BigStorageCageDetails::getSlot)


@@ -466,6 +539,10 @@


                    bigStorageCageDetailsService.updateBySlot(storageCageDTOList, Const.GLASS_STATE_OUT);


                } else {


                    bigStorageCageDetailsService.updateBySlot(storageCageDTOList, Const.GLASS_STATE_IN);


                    //按照格子信息更新对应的设备id


                    List<Integer> slotList = storageCageDTOList.stream().map(UpdateBigStorageCageDTO::getTargetSlot).distinct().collect(Collectors.toList());


                    bigStorageCageDetailsService.updateDeviceIdBySlot(slotList);




                }


                log.info("4、大理片笼进片状态已完成已完成的玻璃信息id:{}", v);


                updateSlotRemainBySlots(outSuccessGlassSlot);


@@ -518,7 +595,7 @@


            Damage damage = new Damage();


            damage.setGlassId(item.getGlassId());


            damage.setLine(item.getStartSlot());


            damage.setWorkingProcedure("磨边");


            damage.setWorkingProcedure("大理片笼");


            damage.setRemark("进笼前卧转立");


            damage.setStatus(1);


            damage.setType(item.getTaskState());


@@ -615,9 +692,18 @@


     */


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


        List<T> outGlassList = list;


        if (!THROUGH_SLOT.equals(list.get(0).getSlot())) {


            //todo:临时解决方案:出片时考虑玻璃碰撞，改为一片一出


            // 界面关闭调度开关 !Const.BIG_STORAGE_BEFORE_DISPATCH.equals(taskType)


            if (list.get(0).getThickness() >= 8) {


                outGlassList = list.subList(0, 1);


            } else {


                List<String> glassIdList = bigStorageGlassRelationInfoService.queryNeedOutGlassId(


                        list.get(0).getEngineerId(), list.get(0).getTemperingLayoutId(), list.get(0).getTemperingFeedSequence());


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


@@ -666,7 +752,9 @@


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


        List<BigStorageCageTask> bigStorageCageTaskList = new ArrayList<>();


        //打车剩余尺寸


        Integer remainWidth = carWidth;


        Integer outCarMaxSize = sysConfigService.queryConfigValue(ConstSysConfig.VERTICAL_OUT_CAR_SIZE);


        Integer glassGap = sysConfigService.queryConfigValue(ConstSysConfig.VERTICAL_GLASS_GAP);


        Integer remainWidth = sysConfigService.queryConfigValue(ConstSysConfig.VERTICAL_CAR_WIDTH);


        for (T e : list) {


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


                break;


@@ -716,6 +804,8 @@


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


                .in(BigStorageCageDetails::getSlot, slotList).in(BigStorageCageDetails::getState, Const.GLASS_STATE_IN_ALL));


        Map<Integer, Double> slotRemainMap = new HashMap<>();


        Integer glassGap = sysConfigService.queryConfigValue(ConstSysConfig.VERTICAL_GLASS_GAP);


        Integer slotWidth = sysConfigService.queryConfigValue(ConstSysConfig.VERTICAL_SLOT_WIDTH);


        //是否存在有格子非空的玻璃


        if (CollectionUtil.isNotEmpty(inSlotGlassList)) {


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