阿尔及利亚代码逻辑修改，页面布局修改

huang

2025-10-20 8b7ae914554652266b31f3bb4237106f1b220cc7

 hangzhoumesParent/moduleService/LoadGlassModule/src/main/java/com/mes/job/OpcLoadGlassTask.java

@@ -62,7 +62,7 @@
    private S7Serializer s7SerializerSPOne;

    @Autowired
    @Qualifier("s7SerializerSP1")
    @Qualifier("s7SerializerSP2")
    private S7Serializer s7SerializerSPTwo;

    private static final List<Integer> LOAD_STATION_01 = Arrays.asList(101, 102);
@@ -81,7 +81,7 @@
    //2、1号上片位是否有原片，原片尺寸是否和上片待上片的尺寸一致
    //3、1号无原片，且没有架子，2号上片位尺寸是否和带上片尺寸一致
    //4、不一致可能出现玻璃破损导致的上一架原片数量不够
    @Scheduled(fixedDelay = 5000)
    @Scheduled(fixedDelay = 2000)
    public void opcLoadGlassOne() {
        opcLoadGlassChild(LOAD_GLASS_DEVICE_ONE_TASK, LOAD_GLASS_ONE_DEVICE);
    }
@@ -91,7 +91,7 @@
        opcLoadGlassChild(LOAD_GLASS_DEVICE_TWO_TASK, LOAD_GLASS_TWO_DEVICE);
    }

    @Scheduled(fixedDelay = 5000)
    @Scheduled(fixedDelay = 2000)
    public void opcLoadGlassOneFinish() {
        opcLoadGlassFinishChid(LOAD_GLASS_DEVICE_ONE_TASK, LOAD_GLASS_ONE_DEVICE);
    }
@@ -125,33 +125,43 @@

    private void opcLoadGlassChild(String tableName, Integer deviceId) {
        S7DataSP s7DataSP = new S7DataSP();
//        s7DataSP.setPlcRequest(1);
//        s7DataSP.setMesConfirm(0);
        if (tableName.equals(LOAD_GLASS_DEVICE_ONE_TASK)) {
            s7DataSP = s7SerializerSPOne.read(S7DataSP.class);
        } else {
            s7DataSP = s7SerializerSPTwo.read(S7DataSP.class);
        }
        log.info("{}上片线，当前上片位信息：{}", deviceId, s7DataSP);

        if (s7DataSP.getPlcRequest() == 0) {
            if (s7DataSP.getMesSend() != 0) {
                S7DataSP resetSend = new S7DataSP();
                resetSend.setMesSend(0);
                s7SerializerSPOne.write(resetSend);
                log.info("{}上片线，PLC请求清零，MES同步清零mesSend", deviceId);
            }
            return;
        }

        // 当PLC请求新任务（plcRequest=1）且无未确认汇报（mesConfirm=0）时处理
        if (s7DataSP.getPlcRequest() != 1 || s7DataSP.getMesConfirm() != 0) {
            log.info("{}上片线，PLC未请求新任务或存在未确认汇报，跳过本次处理", deviceId);
            return;
        }

        Engineering engineering = engineeringMapper.selectOne(new LambdaQueryWrapper<Engineering>()
                .eq(Engineering::getState, Const.ENGINEERING_RUNNING).eq(Engineering::getStationCell, deviceId));
                .eq(Engineering::getState, Const.ENGINEERING_RUNNING)
                .eq(Engineering::getStationCell, deviceId));
        if (null == engineering) {
            log.info("{}上片线，没有工程任务", deviceId);
            return;
        }
        //任务暂停
        S7DataSP task = new S7DataSP();
        if ("0".equals(s7DataSP.getInkageState().toString())) {
            log.info("{}上片线，处于离线状态：{}，结束本地上片请求", deviceId, s7DataSP.getInkageState().toString());
            return;
        }
        if (s7DataSP.getTaskRunning()) {
            log.info("{}上片线，有正在执行的任务，结束本地上片请求", deviceId);
            return;
        }

        List<UpPattenUsageVO> pattenUsageList = upPattenUsageMapper.queryRawGlassByEngineeringId(engineering.getEngineerId());
        log.info("按照当前获取到正在需要上片的原片信息有：{}", pattenUsageList);
        if (CollectionUtils.isEmpty(pattenUsageList)) {
            log.info("当前工程需要上片的原片信息为空，任务已结束");
            //todo：是否将工程状态改为已完成
            return;
        }
        Map<String, List<UpPattenUsageVO>> upListMap = pattenUsageList.stream()
@@ -162,7 +172,7 @@
        List<Integer> loadStation = LOAD_GLASS_DEVICE_ONE_TASK.equals(tableName) ? LOAD_STATION_01 : LOAD_STATION_02;
        List<RawGlassStorageDetails> loadStationList = rawGlassStorageDetailsService.list(new LambdaQueryWrapper<RawGlassStorageDetails>()
                .inSql(RawGlassStorageDetails::getSlot, "select slot from raw_glass_storage_station where enable_state = 1")
                .in(RawGlassStorageDetails::getState, Const.RAW_GLASS_STATE_IN_ALL)
                .in(RawGlassStorageDetails::getState, Const.RAW_GLASS_STATE_IN)
                .eq(RawGlassStorageDetails::getDeviceId, deviceId));
        if (CollectionUtils.isEmpty(loadStationList)) {
            log.info("当前上片线路两个上片位都没有原片信息，结束本次上片任务，等待仓储调度任务");
@@ -177,14 +187,18 @@
            }
            int number = Math.min(twoLoadStation.getRemainQuantity(), usageVOS.size());
            //生成上片任务
            LoadGlassDeviceTaskHistory task = new LoadGlassDeviceTaskHistory();
            task.setTotalCount(number);
            task.setTaskRunning(Boolean.TRUE);
            task.setTaskRunning(1);
            task.setRawGlassWidth((int) usageVOS.get(0).getWidth());
            task.setRawGlassHeight((int) usageVOS.get(0).getHeight());
            task.setSlot(loadStation.get(1));
            task.setSlot(loadStation.get(0));
            task.setRawGlassFilmsId(usageVOS.get(0).getFilmsId());
            task.setEngineeringId(usageVOS.get(0).getEngineeringId());
            saveHistoryTask(task, deviceId);

            S7DataSP s7DataSPWrite = new S7DataSP();
            s7DataSPWrite.setTotalCount(number);
            s7DataSPWrite.setTaskRunning(Boolean.TRUE);
            s7DataSPWrite.setMesSend(1);
            s7DataSPWrite.setRawGlassWidth((int) usageVOS.get(0).getWidth());
            s7DataSPWrite.setRawGlassHeight((int) usageVOS.get(0).getHeight());
            s7DataSPWrite.setSlot(loadStation.get(1));
@@ -193,7 +207,6 @@
            } else {
                s7SerializerSPTwo.write(s7DataSPWrite);
            }
            saveHistoryTask(task, deviceId);
            return;
        }
        //尺寸不一样或者原片数量大于0
@@ -203,14 +216,23 @@
        }
        //生成上片任务
        int number = Math.min(oneLoadStation.getRemainQuantity(), usageVOS.size());
        LoadGlassDeviceTaskHistory task = new LoadGlassDeviceTaskHistory();
        task.setTotalCount(number);
        task.setTaskRunning(Boolean.TRUE);
        task.setTaskRunning(1);
        task.setRawGlassWidth((int) usageVOS.get(0).getWidth());
        task.setRawGlassHeight((int) usageVOS.get(0).getHeight());
        task.setRawGlassThickness((int) usageVOS.get(0).getThickness());
        task.setSlot(loadStation.get(0));
        task.setRawGlassFilmsId(usageVOS.get(0).getFilmsId());
        task.setEngineeringId(usageVOS.get(0).getEngineeringId());
        saveHistoryTask(task, deviceId);

        UpPattenUsage upPattenUsage = upPattenUsageMapper.selectById(usageVOS.get(0).getId());
        upPattenUsage.setState(101);
        upPattenUsageMapper.updateById(upPattenUsage);

        S7DataSP s7DataSPWrite = new S7DataSP();
        s7DataSPWrite.setTotalCount(number);
        s7DataSPWrite.setTaskRunning(Boolean.TRUE);
        s7DataSPWrite.setMesSend(1);
        s7DataSPWrite.setRawGlassWidth((int) usageVOS.get(0).getWidth());
        s7DataSPWrite.setRawGlassHeight((int) usageVOS.get(0).getHeight());
        s7DataSPWrite.setSlot(loadStation.get(0));
@@ -219,71 +241,78 @@
        } else {
            s7SerializerSPTwo.write(s7DataSPWrite);
        }
        saveHistoryTask(task, deviceId);
    }

    private void opcLoadGlassFinishChid(String tableName, Integer deviceId) {
        S7DataSP s7DataSP = new S7DataSP();
//        s7DataSP.setPlcReport(1);
//        s7DataSP.setMesConfirm(0);
        if (tableName.equals(LOAD_GLASS_DEVICE_ONE_TASK)) {
            s7DataSP = s7SerializerSPOne.read(S7DataSP.class);
        } else {
            s7DataSP = s7SerializerSPTwo.read(S7DataSP.class);
        }
        log.info("{}上片线，当前上片位信息：{}", deviceId, s7DataSP);
        if (s7DataSP.getTaskRunning().toString().equals(Const.ENGINEERING_NEW)) {
            log.info("无任务,结束");

        if (s7DataSP.getPlcReport() == 0) {
            if (s7DataSP.getMesConfirm() != 0) {
                S7DataSP resetConfirm = new S7DataSP();
                resetConfirm.setMesConfirm(0);
                s7SerializerSPOne.write(resetConfirm);
                log.info("{}上片线，PLC汇报清零，MES同步清零mesConfirm", deviceId);
            }
            return;
        }
        if (Integer.parseInt(s7DataSP.getTaskState().toString()) <= 1) {
            log.info("任务正在执行,结束");

        if (s7DataSP.getPlcReport() == 0 || s7DataSP.getMesConfirm() != 0) {
            log.info("{}上片线，无PLC汇报或已确认，跳过本次处理", deviceId);
            return;
        }
        //获取任务完成情况
//         已完成数量  破损数量
        Integer finishCount = Integer.parseInt(s7DataSP.getFinishCount().toString());
        Integer damageCount = Integer.parseInt(s7DataSP.getDamageCount().toString());
        Integer slot = Integer.parseInt(s7DataSP.getSlot().toString());
        LoadGlassDeviceTaskHistory unconfirmedTask = loadGlassDeviceTaskHistoryService.getOne(
                new LambdaQueryWrapper<LoadGlassDeviceTaskHistory>()
                        .eq(LoadGlassDeviceTaskHistory::getStation, deviceId)
                        .eq(LoadGlassDeviceTaskHistory::getTaskState, Const.RAW_GLASS_TASK_RUNNING)
        );
        String upUsageId = unconfirmedTask.getEngineeringId();
        if (s7DataSP.getPlcReport() == 1) {
            // 汇报成功：更新上片记录为“成功”
            upPattenUsageMapper.update(null,
                    new LambdaUpdateWrapper<UpPattenUsage>()
                            .set(UpPattenUsage::getState, Const.LOAD_RAW_GLASS_SUCCESS)
                            .eq(UpPattenUsage::getEngineeringId, upUsageId)
                            .eq(UpPattenUsage::getState, 101)
            );
            unconfirmedTask.setTaskState(Const.RAW_GLASS_TASK_SUCCESS);
            unconfirmedTask.setFinishCount(unconfirmedTask.getFinishCount() + 1);
            log.info("{}上片线，任务汇报成功，更新上片记录[{}]为成功", deviceId, upUsageId);
        } else if (s7DataSP.getPlcReport() == 2) {
            // 汇报破损
            unconfirmedTask.setTaskState(200);
            unconfirmedTask.setDamageCount(unconfirmedTask.getDamageCount() + 1);
            log.warn("{}上片线，任务汇报破损，上片记录[{}]标记为破损", deviceId,  upUsageId);
        }
        unconfirmedTask.setUpdateTime(new Date());
        loadGlassDeviceTaskHistoryService.updateById(unconfirmedTask);

        //更新当前架子上的原片剩余情况
        rawGlassStorageDetailsService.update(new UpdateWrapper<RawGlassStorageDetails>()
                .inSql("slot", "select slot from raw_glass_storage_station where enable_state = 1")
//                .eq("slot", task.getSlot())
                .eq("slot", slot)
                .eq("slot", unconfirmedTask.getSlot())
                .eq("state", Const.RAW_GLASS_STATE_IN)
                .setSql("remain_quantity = remain_quantity - " + (finishCount + damageCount)));
        //更新工程下的原片数量 todo:sql待优化

        if (finishCount > 0) {
            List<Integer> ids = upPattenUsageMapper.queryFinishByEngineering(deviceId, finishCount);
            upPattenUsageMapper.update(null, new LambdaUpdateWrapper<UpPattenUsage>()
                    .in(UpPattenUsage::getId, ids)
                    .set(UpPattenUsage::getState, Const.LOAD_RAW_GLASS_SUCCESS));
        }
        //任务表数据情况
                .setSql("remain_quantity = GREATEST(remain_quantity - 1, 0)"));
        //汇报字给1
        S7DataSP s7DataSPWrite = new S7DataSP();
        s7DataSPWrite.setTaskRunning(Boolean.FALSE);
        s7DataSPWrite.setTotalCount(0);
        s7DataSPWrite.setRawGlassWidth(0);
        s7DataSPWrite.setRawGlassHeight(0);
        s7DataSPWrite.setSlot(0);
        if (LOAD_GLASS_ONE_DEVICE.equals(deviceId)) {
        s7DataSPWrite.setMesConfirm(1);
            s7SerializerSPOne.write(s7DataSPWrite);
        } else {
            s7SerializerSPTwo.write(s7DataSPWrite);
        }
        loadGlassDeviceTaskHistoryService.update(new LambdaUpdateWrapper<LoadGlassDeviceTaskHistory>()
                .set(LoadGlassDeviceTaskHistory::getTaskState, Const.RAW_GLASS_TASK_SUCCESS)
                .eq(LoadGlassDeviceTaskHistory::getTaskState, Const.RAW_GLASS_TASK_NEW)
                .eq(LoadGlassDeviceTaskHistory::getStation, deviceId)
        );
    }

    private boolean saveHistoryTask(S7DataSP task, Integer deviceId) {
    private boolean saveHistoryTask(LoadGlassDeviceTaskHistory task, Integer deviceId) {
        LoadGlassDeviceTaskHistory taskHistory = new LoadGlassDeviceTaskHistory();
        BeanUtils.copyProperties(task, taskHistory);
        taskHistory.setStation(deviceId);
        taskHistory.setCreateTime(new Date());
        taskHistory.setTaskState(Const.RAW_GLASS_TASK_NEW);
        taskHistory.setTaskState(Const.RAW_GLASS_TASK_RUNNING);
        loadGlassDeviceTaskHistoryService.save(taskHistory);
        return Boolean.TRUE;
    }