1、任务新增计时功能，日志打印每次任务执行的周期 2、卧式理片笼更新出片规则：都为禁用（2），笼子不出玻璃；存在一个禁用，07片台可以存玻璃；都非禁用...

zhoushihao

2024-07-09 0477b72d30cfe7d412edeb237aa587b1c5242207

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

@@ -78,11 +78,13 @@
    @Value("${mes.outCarMaxSize}")
    private Integer outCarMaxSize;

    @Value("${mes.galssGap}")
    private Integer galssGap;
    @Value("${mes.glassGap}")
    private Integer glassGap;

    @Scheduled(fixedDelay = 300)
    public void plcToHomeEdgScan() {
        Date startDate = new Date();
        log.info("大理片笼扫码任务开始执行时间：{}", startDate);
        PlcParameterObject plcParameterObject = S7object.getinstance().PlcMesObject;
        String d01Id = plcParameterObject.getPlcParameter("D01ID").getValue();
        String d04Id = plcParameterObject.getPlcParameter("D04ID").getValue();
@@ -93,13 +95,10 @@
        String mesD01Address = plcParameterObject.getPlcParameter("MESToD01").getAddress();
        String mesD04Address = plcParameterObject.getPlcParameter("MESToD04").getAddress();
        String d01ToMES = plcParameterObject.getPlcParameter("D01ToMES").getValue();
        if (!REQUEST_WORD.equals(d01ToMES)) {
            log.info("请求字为{}，结束本次扫描进卧转立任务", d01ToMES);
            return;
        }
        String d04ToMES = plcParameterObject.getPlcParameter("D04ToMES").getValue();

        log.info("1、获取d01Id扫描ID为：{};获取d04Id扫描ID为：{};", d01Id, d04Id);
        if (StringUtils.isBlank(d01Id) && StringUtils.isBlank(d04Id)) {
        log.info("1、获取d01Id扫描ID为：{}，请求字为{};获取d04Id扫描ID为：{}，请求字为{};", d01Id, d01ToMES, d04Id, d04ToMES);
        if (StringUtils.isBlank(d01ToMES) && StringUtils.isBlank(d04ToMES)) {
            log.info("两条线未收到进片任务，结束本次扫描进卧转立任务");
            return;
        }
@@ -107,43 +106,34 @@
            log.info("两条线卧转立均在执行任务，结束本次扫描进卧转立任务");
            return;
        }
//        Boolean flag01 = Boolean.FALSE;
//        Boolean flag04 = Boolean.FALSE;
        //按照线路及玻璃id获取相邻两块玻璃 卧转立上的玻璃
        if (StringUtils.isNotBlank(d01Id) && (StringUtils.isBlank(d02State) || !REQUEST_WORD.equals(d03State))) {
        if (REQUEST_WORD.equals(d01ToMES) && (StringUtils.isBlank(d02State) || !REQUEST_WORD.equals(d03State))) {
            judgeGlassTypeStatus(d01Id, Const.A09_OUT_TARGET_POSITION, mesD01Address);
        }
        if (StringUtils.isNotBlank(d04Id) && !REQUEST_WORD.equals(d05State)) {
        if (REQUEST_WORD.equals(d04ToMES) && !REQUEST_WORD.equals(d05State)) {
            judgeGlassTypeStatus(d04Id, Const.A10_OUT_TARGET_POSITION, mesD04Address);
        }
        log.info("结束扫码任务");
//        if (flag01 && flag04) {
//            //比较最早一片任务的版图id及版序 求出卧转立的线路
//            Integer startLine = getStartLine();
//            //计算目标格子，发送启动任务
//            computeTargetByLine(startLine);
//        } else if (flag01 || flag04) {
//            Integer startLine = flag01.equals(Boolean.TRUE) ? Const.A09_OUT_TARGET_POSITION : Const.A10_OUT_TARGET_POSITION;
//            //计算目标格子，发送启动任务
//            computeTargetByLine(startLine);
//        } else {
//            log.info("两条线未收到进片任务，结束本次扫描进卧转立任务");
//        }
        Date endDate = new Date();
        log.info("大理片笼扫码任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime());
    }

    @Scheduled(fixedDelay = 300)
    public void plcToHomeEdgFreeCarTask() {
        Date startDate = new Date();
        log.info("大理片笼空车进片任务开始执行时间：{}", startDate);
        PlcParameterObject plcParameterObject = S7object.getinstance().PlcMesObject;
        String e01Status = plcParameterObject.getPlcParameter("E01State").getValue();
        String d03ToMES = plcParameterObject.getPlcParameter("D03ToMES").getValue();
        String d05ToMES = plcParameterObject.getPlcParameter("D05ToMES").getValue();
        log.info("执行空车送片任务，获取到的大车状态为{}，卧转立状态分别为d03:{}，d05:{}", e01Status, d03ToMES, d05ToMES);
        if (REQUEST_WORD.equals(e01Status)) {
            log.info("进片大车非空闲，结束送片任务");
            Date endDate = new Date();
            log.info("进片大车非空闲，结束送片任务，任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime());
            return;
        }
        if (!REQUEST_WORD.equals(d03ToMES) && !REQUEST_WORD.equals(d05ToMES)) {
            log.info("卧转立没有送片请求，结束送片任务");
            Date endDate = new Date();
            log.info("卧转立没有送片请求，结束送片任务，任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime());
            return;
        }
        LambdaQueryWrapper<BigStorageCageFeedTask> wrapper = new LambdaQueryWrapper<BigStorageCageFeedTask>()
@@ -154,14 +144,15 @@
        if (CollectionUtils.isNotEmpty(feedTaskList)) {
            if (feedTaskList.size() == 1) {
                computeTargetByLine(feedTaskList.get(0).getLine());
                return;
            } else {
                //比较最早一片任务的版图id及版序 求出卧转立的线路
                Integer startLine = getStartLine();
//            //计算目标格子，发送启动任务
                computeTargetByLine(startLine);
                return;
            }
            Date endDate = new Date();
            log.info("大理片笼空车进片任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime());
            return;
        }
        String d01Id = plcParameterObject.getPlcParameter("D01ID").getValue();
        String d04Id = plcParameterObject.getPlcParameter("D04ID").getValue();
@@ -174,7 +165,8 @@
        //获取两条线卧转立是否有玻璃，且任务状态都为2
        List<Integer> lineList = bigStorageCageFeedTaskService.querySitToUpGlass();
        if (CollectionUtils.isEmpty(lineList)) {
            log.info("两条线卧转立为空或者有进片任务未完成，结束任务");
            Date endDate = new Date();
            log.info("两条线卧转立为空或者有进片任务未完成，结束任务，大理片笼空车进片任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime());
            return;
        }
        Integer lineFirst = lineList.get(0);
@@ -191,6 +183,8 @@
                    computeTargetByLine(lineFirst);
                }
            }
            Date endDate = new Date();
            log.info("大理片笼空车进片任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime());
            return;
        }
        //两条先均可执行进片任务，判断两条线是否进片请求是否都为空
@@ -199,6 +193,8 @@
            Integer line = getStartLine();
            //计算任务表进片格子 发送进片任务
            computeTargetByLine(line);
            Date endDate = new Date();
            log.info("大理片笼空车进片任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime());
            return;
        } else if (StringUtils.isNotBlank(d01Id) && StringUtils.isNotBlank(d04Id)) {
//            todo:两个都有进片玻璃
@@ -212,6 +208,8 @@
            } else if (computeIsRun(Const.A10_OUT_TARGET_POSITION, d04Id)) {
                computeTargetByLine(Const.A10_OUT_TARGET_POSITION);
            } else {
                Date endDate = new Date();
                log.info("大理片笼空车进片任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime());
                return;
            }
        } else {
@@ -221,12 +219,16 @@
            //获取进片请求玻璃为空的，计算任务表进片格子 发送进片任务
            computeTargetByLine(outLine);
        }

        Date endDate = new Date();
        log.info("大理片笼空车进片任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime());
    }

    @Scheduled(fixedDelay = 300)
    public void plcToHomeEdgOutTask() {

        Date startDate = new Date();
        log.info("大理片笼空车进片任务开始执行时间：{}", startDate);
        PlcParameterObject plcMesObject = S7object.getinstance().PlcMesObject;
        String mesToPLCAddress = plcMesObject.getPlcParameter("MESToPLC").getAddress();
        List<BigStorageCageOutTask> outingList = bigStorageCageOutTaskService.list(new LambdaQueryWrapper<BigStorageCageOutTask>().eq(BigStorageCageOutTask::getTaskState, Const.BIG_STORAGE_OUT_NEW));
        Assert.isTrue(CollectionUtils.isEmpty(outingList), "有正在执行出片的任务，结束当前出片线程");

@@ -239,14 +241,18 @@
                .orderBy(Boolean.TRUE, sequenceOrder, TemperingGlassInfo::getTemperingFeedSequence));
        if (CollectionUtils.isNotEmpty(temperingGlassInfoList)) {
            log.info("有正在出片的钢化任务");
            computeOutGlassInfo(temperingGlassInfoList, Boolean.TRUE);
            computeOutGlassInfo(temperingGlassInfoList, Boolean.TRUE, mesToPLCAddress);
            Date endDate = new Date();
            log.info("大理片笼出片任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime());
            return;
        }
        //是否有人工下片任务   有直接出
        List<BigStorageCageDetails> artificialList = bigStorageCageDetailsService.list(new LambdaQueryWrapper<BigStorageCageDetails>()
                .eq(BigStorageCageDetails::getState, Const.GLASS_STATE_ARTIFICIAL).orderByDesc(BigStorageCageDetails::getWidth));
        if (CollectionUtils.isNotEmpty(artificialList)) {
            computeOutGlassInfo(temperingGlassInfoList, Boolean.FALSE);
            computeOutGlassInfo(artificialList, Boolean.FALSE, mesToPLCAddress);
            Date endDate = new Date();
            log.info("大理片笼出片任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime());
            return;
        }
        //钢化优先：获取理片笼  玻璃小片  破损表 数量   判断笼内版图是否到齐
@@ -263,7 +269,9 @@
                    .eq(GlassInfo::getTemperingLayoutId, temperingLayoutDTO.getTemperingLayoutId())
                    .eq(GlassInfo::getEngineerId, temperingLayoutDTO.getEngineerId()));
            temperingGlassInfoService.saveBatch(temperingGlassInfos);
            computeOutGlassInfo(temperingGlassInfoList, Boolean.TRUE);
            computeOutGlassInfo(temperingGlassInfoList, Boolean.TRUE, mesToPLCAddress);
            Date endDate = new Date();
            log.info("大理片笼出片任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime());
            return;
        }
        //未到齐 执行内部调度任务
@@ -273,7 +281,7 @@
            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() - galssGap;
                int slotWidth = carWidth - first.getRemainWidth() - glassGap;
                if (first.getMinSequence() == second.getMaxSequence() + 1
                        && second.getRemainWidth() > slotWidth) {
                    List<BigStorageCageDetails> list = bigStorageCageDetailsService.list(new LambdaQueryWrapper<BigStorageCageDetails>()
@@ -281,6 +289,10 @@
                    List<BigStorageCageOutTask> outTasks = list.stream().map(e -> new BigStorageCageOutTask(e.getGlassId(), first.getSlot(), second.getSlot(),
                            slotWidth, 0, 0, 1)).collect(Collectors.toList());
                    bigStorageCageOutTaskService.saveBatch(outTasks);
                    S7object.getinstance().plccontrol.writeWord(mesToPLCAddress, 1);
                    log.info("已向plc发送出片任务确认，地址为：{}", mesToPLCAddress);
                    Date endDate = new Date();
                    log.info("大理片笼出片任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime());
                    return;
                }
            }
@@ -312,10 +324,10 @@

        Boolean flag = Boolean.TRUE;
        //2、获取卧转立
        Integer widthFirst = edgGlassTaskInfoList.get(0).getWidth();
        Integer widthFirst = Math.max(edgGlassTaskInfoList.get(0).getWidth() / 10, edgGlassTaskInfoList.get(0).getHeight() / 10);
        if (edgGlassTaskInfoList.size() == 1) {
            if (remainWidth >= widthFirst) {
                if (glassCount <= 5) {
                if (glassCount < inCarMaxSize) {
                    addFeedTask(glassId, line, Const.BIG_STORAGE_IN_WAIT, widthFirst);
                } else {
                    addFeedTask(glassId, line, Const.BIG_STORAGE_IN_RUN, widthFirst);
@@ -324,10 +336,10 @@
                flag = Boolean.FALSE;
            }
        } else {
            Integer widthSecond = edgGlassTaskInfoList.get(1).getWidth();
            Integer widthSecond = Math.max(edgGlassTaskInfoList.get(1).getWidth() / 10, edgGlassTaskInfoList.get(1).getHeight() / 10);
            if (remainWidth >= widthFirst) {
                if (remainWidth - widthFirst - galssGap >= widthSecond) {
                    if (glassCount <= inCarMaxSize - 1) {
                if (remainWidth - widthFirst - glassGap >= widthSecond) {
                    if (glassCount < inCarMaxSize) {
                        addFeedTask(glassId, line, Const.BIG_STORAGE_IN_WAIT, widthFirst);
                    } else {
                        addFeedTask(glassId, line, Const.BIG_STORAGE_IN_RUN, widthFirst);
@@ -433,6 +445,7 @@
    }

    private void sendTaskListToPLC(List<BigStorageCageFeedTask> taskList, Integer line) {
        log.info("送片任务发送进片玻璃信息");
        S7control s7control = S7object.getinstance().plccontrol;
        PlcParameterObject plcMesObject = S7object.getinstance().PlcMesObject;
        String mesD03Address = plcMesObject.getPlcParameter("MESToD03").getAddress();
@@ -443,10 +456,10 @@
            s7control.writeWord(plcMesObject.getPlcParameter("TargetAddToImport" + i).getAddress(), taskList.get(i - 1).getTargetSlot());
        }
        s7control.writeWord(outLine, 2);
        log.info("送片任务已发送完成，任务线路为：{}，启动地址为{}", line, outLine);
        log.info("送片任务已发送完成，任务线路为：{}，启动地址为{},确认字为{}", line, outLine, 2);
    }

    private <T extends BigStorageCageBaseInfo> Boolean computeOutGlassInfo(List<T> list, Boolean isTempering) {
    private <T extends BigStorageCageBaseInfo> Boolean computeOutGlassInfo(List<T> list, Boolean isTempering, String mesToPLCAddress) {
        //任务数据  获取车子存放玻璃最大数量  玻璃间隔
        List<BigStorageCageOutTask> bigStorageCageOutTaskList = new ArrayList<>();
        //打车剩余尺寸
@@ -455,7 +468,7 @@
            if (bigStorageCageOutTaskList.size() > outCarMaxSize || e.getWidth() > remainWidth) {
                break;
            }
            remainWidth = remainWidth - (int) e.getWidth() - galssGap;
            remainWidth = remainWidth - (int) e.getWidth() - glassGap;
            if (isTempering) {
                bigStorageCageOutTaskList.add(new BigStorageCageOutTask(e.getGlassId(), e.getSlot(), Const.TEMPERING_OUT_TARGET_POSITION,
                        (int) e.getWidth() * 10, 0, 0, 1));
@@ -475,6 +488,8 @@
                .in(BigStorageCageDetails::getGlassId, glassIds));
        //更新笼子内格子的剩余尺寸
        updateSlotRemain(list, glassIds);
        S7object.getinstance().plccontrol.writeWord(mesToPLCAddress, 1);
        log.info("已向plc发送出片任务确认，地址为：{}", mesToPLCAddress);
        return Boolean.TRUE;
    }

@@ -490,7 +505,7 @@
        List<Integer> slotList = list.stream().map(T::getSlot).distinct().collect(Collectors.toList());
        //获取待出去的玻璃信息（等下车出去的玻璃）
        Map<Integer, Double> slotRemainMap = list.stream().filter(e -> !taskGlassIds.contains(e.getGlassId()))
                .collect(Collectors.groupingBy(T::getSlot, Collectors.summingDouble(item -> item.getWidth() + galssGap)));
                .collect(Collectors.groupingBy(T::getSlot, Collectors.summingDouble(item -> item.getWidth() + glassGap)));
        if (CollectionUtils.isNotEmpty(slotRemainMap)) {
            //按照格子号更新剩余尺寸
            slotRemainMap.forEach((e, v) -> {