1、 钢化前出片加上卧转立校验

zhoushihao

2025-12-01 3defdfb435a1a9b3822f5c1b7f9b9995ed986c1f

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

@@ -3,9 +3,10 @@
import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.core.lang.Assert;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.github.xingshuangs.iot.protocol.s7.serializer.S7Serializer;
import com.github.xingshuangs.iot.protocol.s7.service.S7PLC;
import com.github.yulichang.toolkit.JoinWrappers;
import com.kangaroohy.milo.model.ReadWriteEntity;
import com.kangaroohy.milo.service.MiloService;
@@ -87,6 +88,9 @@
    @Autowired
    @Qualifier("s7SerializerDLPTwo")
    private S7Serializer s7SerializerDLPTwo;
    @Autowired
    @Qualifier("s7plcWZL")
    private S7PLC s7plcWZL;

    @Resource
    SysConfigService sysConfigService;
@@ -104,6 +108,8 @@
    private static final String ALARM_TYPE = "钢化大理片";
    private static final String ALARM_CODE_SIZE = "sizeSame";
    private static final String ALARM_CODE_ID = "idSame";
    private static final String ALARM_CODE_SLOT = "slotLess";
    private static final String ALARM_CODE_OVER = "overSize";

    @Resource
    private RedisUtil redisUtil;
@@ -231,6 +237,13 @@
                        .ge(BigStorageCage::getMaxThickness, entry.getKey()));
                if (count < entry.getValue()) {
                    log.info("笼内格子剩余数量不足，结束本次进片");
                    ProductAlarmInfo alarmInfo = new ProductAlarmInfo();
                    alarmInfo.setState(Const.LOAD_RAW_GLASS_NEW);
                    alarmInfo.setAlarmModule(ALARM_MODULE);
                    alarmInfo.setAlarmType(ALARM_TYPE);
                    alarmInfo.setAlarmCode(ALARM_CODE_SLOT);
                    alarmInfo.setAlarmMessage(count + "");
                    productAlarmInfoService.save(alarmInfo);
                    //向plc发送报警:笼内格子剩余数量不足
//                    miloService.writeToOpcWord(generateReadWriteEntity("DLP1A.DLP1A.alarmSignal", 16));
                    s7DataDLPOne = new S7DataDLPOne();
@@ -247,6 +260,13 @@
                    .in(BigStorageCageDetails::getState, Const.GLASS_STATE_IN_ALL));
            if (count > 0) {
                log.info("直通片台存在玻璃，结束本次进片");
//                ProductAlarmInfo alarmInfo = new ProductAlarmInfo();
//                alarmInfo.setState(Const.LOAD_RAW_GLASS_NEW);
//                alarmInfo.setAlarmModule(ALARM_MODULE);
//                alarmInfo.setAlarmType(ALARM_TYPE);
//                alarmInfo.setAlarmCode(ALARM_CODE_OVER);
//                alarmInfo.setAlarmMessage("");
//                productAlarmInfoService.save(alarmInfo);
                //向plc发送报警:直通片台存在玻璃，无法继续直通
//                miloService.writeToOpcWord(generateReadWriteEntity("DLP1A.DLP1A.alarmSignal", 64));
                s7DataDLPOne = new S7DataDLPOne();
@@ -373,6 +393,17 @@
            log.info("当前未收到出片请求，结束出片任务");
            return;
        }
        try {
            int outRequest = s7plcWZL.readUInt16("DB51.8");
            if (outRequest == 0){
                log.info("当前未收到卧转立允许出片请求，结束出片任务");
                return;
            }
        } catch (Exception e) {
            log.error("读取卧转立信号异常", e);
            return;
        }

        //获取出片任务表
        List<BigStorageCageTask> outTaskList = getOutTaskList(s7DataWLTwo);
        if (CollectionUtil.isNotEmpty(outTaskList)) {
@@ -398,6 +429,8 @@
                LambdaQueryWrapper<BigStorageCage> queryWrapper = new LambdaQueryWrapper<BigStorageCage>()
                        .eq(BigStorageCage::getRemainWidth, slotWidth)
                        .eq(BigStorageCage::getEnableState, Const.SLOT_ON)
                        .le(BigStorageCage::getMinThickness, info.getThickness())
                        .ge(BigStorageCage::getMaxThickness, info.getThickness())
                        .orderByAsc(BigStorageCage::getDeviceId).orderByAsc(BigStorageCage::getSlot)
                        .last("limit 1");

@@ -462,13 +495,30 @@

            String temperingEngineerId = redisUtil.getCacheObject("temperingEngineerId");
            if (StringUtils.isNotBlank(temperingEngineerId)) {
                TemperingGlassInfo temperingGlassInfo = temperingGlassInfoService.getOne(new QueryWrapper<TemperingGlassInfo>()
                        .select("Top 1 *")
                        .eq("engineer_id", temperingEngineerId)
                        .orderByDesc("tempering_layout_id"));
                List<TemperingGlassInfo> temperingGlassInfoList = temperingGlassInfoService.list(
                        new LambdaQueryWrapper<TemperingGlassInfo>()
                                .eq(TemperingGlassInfo::getEngineerId, temperingEngineerId)
                                .orderByAsc(TemperingGlassInfo::getId)
                );
                int temperingLayoutId = 1;
                if (temperingGlassInfo != null) {
                    temperingLayoutId = temperingGlassInfo.getTemperingLayoutId() + 1;
                if (CollectionUtils.isEmpty(temperingGlassInfoList)) {
                    temperingLayoutId = 1;
                } else {
                    List<Integer> tempIds = temperingGlassInfoList.stream()
                            .map(TemperingGlassInfo::getTemperingLayoutId)
                            .distinct()
                            .sorted()
                            .collect(Collectors.toList());

                    int expected = 1;
                    for (int current : tempIds) {
                        if (current > expected) {
                            break; // 找到第一个缺失值，跳出循环
                        } else if (current == expected) {
                            expected++; // 连续则递增期望的值
                        }
                    }
                    temperingLayoutId = expected; // 缺失则为expected，连续则为max+1
                }
                List<GlassInfo> glassInfos = glassInfoService.list(new LambdaQueryWrapper<GlassInfo>().eq(GlassInfo::getEngineerId, temperingEngineerId).eq(GlassInfo::getTemperingLayoutId, temperingLayoutId));
                if (CollectionUtil.isEmpty(glassInfos)) {
@@ -559,6 +609,7 @@
                    .eq(BigStorageCage::getEnableState, Const.SLOT_ON));
            //定义10个格子为阈值
            if (count <= 10) {
                log.info("笼子超过阈值，执行4号笼子调度逻辑");
                //获取序号为1的格子 将格子内的所有玻璃送到对应的笼子
                BigStorageCage bigStorageCage = bigStorageCageService.getOne(new LambdaQueryWrapper<BigStorageCage>()
                        .eq(BigStorageCage::getRemainWidth, slotWidth)
@@ -566,15 +617,18 @@
                        .in(BigStorageCage::getDeviceId, Arrays.asList(5, 6))
                        .orderByAsc(BigStorageCage::getDeviceId).orderByAsc(BigStorageCage::getSlot)
                        .last("limit 1"));

                list = bigStorageCageDetailsService.queryNeedDispatch();
                computeOutGlassInfoByVirtualSlot(list, "big_storage_cage_out_one_task",
                        bigStorageCage.getSlot(), Const.GLASS_STATE_SCHEDULE_ING, Const.BIG_STORAGE_BEFORE_DISPATCH);
                List<Integer> slotList = new ArrayList<>();
                slotList.add(bigStorageCage.getSlot());
                slotList.add(list.get(0).getSlot());
                updateSlotRemainBySlots(slotList);
                return;
                if (null != bigStorageCage) {
                    list = bigStorageCageDetailsService.queryNeedDispatch();
                    if (CollectionUtil.isNotEmpty(list)) {
                        computeOutGlassInfoByVirtualSlot(list, "big_storage_cage_out_one_task",
                                bigStorageCage.getSlot(), Const.GLASS_STATE_SCHEDULE_ING, Const.BIG_STORAGE_BEFORE_DISPATCH);
                        List<Integer> slotList = new ArrayList<>();
                        slotList.add(bigStorageCage.getSlot());
                        slotList.add(list.get(0).getSlot());
                        updateSlotRemainBySlots(slotList);
                        return;
                    }
                }
            }
            //生成调度任务按照组号组序由1开始依次往5号笼子送小片
            BigStorageSlotDTO slotDTO = bigStorageCageDetailsService.queryNeedDispatchSlotBySequence();
@@ -972,7 +1026,7 @@
//        if (!THROUGH_SLOT.equals(list.get(0).getSlot())) {
//            临时解决方案:出片时考虑玻璃碰撞，改为一片一出
        // 界面关闭调度开关 !Const.BIG_STORAGE_BEFORE_DISPATCH.equals(taskType)
        if (list.get(0).getSlot() >= 500 && list.get(0).getThickness() > 8) {
        if (list.get(0).getSlot() >= 500 && list.get(0).getThickness() > 7) {
            outGlassList = list.subList(0, 1);
        } else {
            List<String> glassIdList = bigStorageGlassRelationInfoService.queryNeedOutGlassId(