添加为钢化开关为空时默认为关闭

ZengTao

2024-07-29 4280f0183e55bae757a2547569c8b33d07096d75

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

@@ -16,10 +16,12 @@
import com.mes.bigstorage.service.BigStorageCageService;
import com.mes.bigstoragetask.entity.BigStorageCageFeedTask;
import com.mes.bigstoragetask.entity.BigStorageCageOutTask;
import com.mes.bigstoragetask.entity.UpdateBigStorageCageDTO;
import com.mes.bigstoragetask.service.BigStorageCageFeedTaskService;
import com.mes.bigstoragetask.service.BigStorageCageOutTaskService;
import com.mes.common.S7object;
import com.mes.common.config.Const;
import com.mes.common.utils.RedisUtil;
import com.mes.damage.entity.Damage;
import com.mes.damage.service.DamageService;
import com.mes.device.PlcParameterObject;
@@ -64,6 +66,9 @@
    private TemperingGlassInfoService temperingGlassInfoService;
    @Resource
    private DamageService damageService;

    @Resource
    private RedisUtil redisUtil;

    private static final String REQUEST_WORD = "1";

@@ -178,11 +183,6 @@
        String d01Id = plcParameterObject.getPlcParameter("D01ID").getValue();
        String d04Id = plcParameterObject.getPlcParameter("D04ID").getValue();
        log.info("1、获取d01Id扫描ID为：{};获取d04Id扫描ID为：{};", d01Id, d04Id);
        //两条线都有进卧转立任务，直接结束
//        if (StringUtils.isNotBlank(d01Id) && StringUtils.isNotBlank(d04Id)) {
//            log.info("两条线都存在进片任务，结束任务");
//            return;
//        }
        //获取两条线卧转立是否有玻璃，且任务状态为1/2
        List<Integer> lineList = bigStorageCageFeedTaskService.querySitToUpGlass();
        if (CollectionUtils.isEmpty(lineList)) {
@@ -244,68 +244,73 @@
        log.info("大理片笼空车进片任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime());
    }

    @Scheduled(fixedDelay = 300)
    @Scheduled(fixedDelay = 5000)
    public void plcToHomeEdgOutTask() {
        Date startDate = new Date();
        log.info("大理片笼空车进片任务开始执行时间：{}", startDate);
        PlcParameterObject plcMesObject = S7object.getinstance().PlcMesObject;
        String e02State = plcMesObject.getPlcParameter("E02State").getAddress();
        String e02State = plcMesObject.getPlcParameter("E02State").getValue();
        if (REQUEST_WORD.equals(e02State)) {
            log.info("出片忙碌，结束出片任务");
            return;
        }
        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), "有正在执行出片的任务，结束当前出片线程");

        //是否有正在钢化的玻璃
        List<TemperingGlassInfo> temperingGlassInfoList = temperingGlassInfoService.selectJoinList(TemperingGlassInfo.class, new MPJLambdaWrapper<TemperingGlassInfo>()
                .selectAll(TemperingGlassInfo.class)
                .leftJoin(BigStorageCageOutTask.class, BigStorageCageOutTask::getGlassId, TemperingGlassInfo::getGlassId)
                .eq(TemperingGlassInfo::getState, Const.TEMPERING_NEW)
                .isNull(BigStorageCageOutTask::getGlassId)
                .orderBy(Boolean.TRUE, sequenceOrder, TemperingGlassInfo::getTemperingFeedSequence));
        if (CollectionUtils.isNotEmpty(temperingGlassInfoList)) {
            log.info("有正在出片的钢化任务");
            computeOutGlassInfo(temperingGlassInfoList, Boolean.TRUE, mesToPLCAddress);
            Date endDate = new Date();
            log.info("大理片笼出片任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime());
        List<BigStorageCageOutTask> outingList = bigStorageCageOutTaskService.list(new LambdaQueryWrapper<BigStorageCageOutTask>()
                .eq(BigStorageCageOutTask::getTaskState, Const.BIG_STORAGE_OUT_NEW));
        if (CollectionUtils.isNotEmpty(outingList)) {
            log.info("有正在执行出片的任务，结束当前出片线程");
            return;
        }
        //是否有人工下片任务   有直接出
        List<BigStorageCageDetails> artificialList = bigStorageCageDetailsService.list(new LambdaQueryWrapper<BigStorageCageDetails>()
                .eq(BigStorageCageDetails::getState, Const.GLASS_STATE_ARTIFICIAL).orderByDesc(BigStorageCageDetails::getWidth));
        if (CollectionUtils.isNotEmpty(artificialList)) {
            computeOutGlassInfo(artificialList, Boolean.FALSE, mesToPLCAddress);
            Date endDate = new Date();
            log.info("大理片笼出片任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime());
            return;
        }
        //钢化优先：获取理片笼  玻璃小片  破损表 数量   判断笼内版图是否到齐
        List<TemperingLayoutDTO> temperingLayoutDTOList = bigStorageCageDetailsService.temperingIsAll();
        if (CollectionUtils.isNotEmpty(temperingLayoutDTOList)) {
            //玻璃到齐包括已出片的
            //到齐，将玻璃小片数据存入钢化小片表，逻辑生成出片任务  结束
            for (TemperingLayoutDTO item : temperingLayoutDTOList) {
                List<TemperingGlassInfo> temperingGlassInfos = glassInfoService.selectJoinList(TemperingGlassInfo.class, JoinWrappers.lambda(GlassInfo.class)
                        .selectAll(GlassInfo.class)
                        .select("-1 as state")
                        .selectAs(BigStorageCageDetails::getSlot, TemperingGlassInfo::getSlot)
                        .innerJoin(BigStorageCageDetails.class, BigStorageCageDetails::getGlassId, GlassInfo::getGlassId)
                        .eq(BigStorageCageDetails::getState, Const.GLASS_STATE_IN)
                        .eq(GlassInfo::getTemperingLayoutId, item.getTemperingLayoutId())
                        .eq(GlassInfo::getEngineerId, item.getEngineerId())
                        .orderBy(Boolean.TRUE, sequenceOrder, GlassInfo::getTemperingFeedSequence));
                if (CollectionUtils.isNotEmpty(temperingGlassInfos)) {
                    temperingGlassInfoService.saveBatch(temperingGlassInfos);
                    computeOutGlassInfo(temperingGlassInfoList, Boolean.TRUE, mesToPLCAddress);
                    Date endDate = new Date();
                    log.info("大理片笼出片任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime());
                    return;
        if (redisUtil.getCacheObject("temperingSwitch")) {
            //是否有正在钢化的玻璃
            List<TemperingGlassInfo> temperingGlassInfoList = temperingGlassInfoService.selectJoinList(TemperingGlassInfo.class, new MPJLambdaWrapper<TemperingGlassInfo>()
                    .selectAll(TemperingGlassInfo.class)
                    .leftJoin(BigStorageCageOutTask.class, BigStorageCageOutTask::getGlassId, TemperingGlassInfo::getGlassId)
                    .eq(TemperingGlassInfo::getState, Const.TEMPERING_NEW)
                    .isNull(BigStorageCageOutTask::getGlassId)
                    .orderBy(Boolean.TRUE, sequenceOrder, TemperingGlassInfo::getTemperingFeedSequence));
            if (CollectionUtils.isNotEmpty(temperingGlassInfoList)) {
                log.info("有正在出片的钢化任务");
                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(artificialList, Boolean.FALSE, mesToPLCAddress);
                Date endDate = new Date();
                log.info("大理片笼出片任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime());
                return;
            }
            //钢化优先：获取理片笼  玻璃小片  破损表 数量   判断笼内版图是否到齐
            List<TemperingLayoutDTO> temperingLayoutDTOList = bigStorageCageDetailsService.temperingIsAll();
            if (CollectionUtils.isNotEmpty(temperingLayoutDTOList)) {
                //玻璃到齐包括已出片的
                //到齐，将玻璃小片数据存入钢化小片表，逻辑生成出片任务  结束
                for (TemperingLayoutDTO item : temperingLayoutDTOList) {
                    List<TemperingGlassInfo> temperingGlassInfos = glassInfoService.selectJoinList(TemperingGlassInfo.class, JoinWrappers.lambda(GlassInfo.class)
                            .selectAll(GlassInfo.class)
                            .select("-1 as state")
                            .selectAs(BigStorageCageDetails::getSlot, TemperingGlassInfo::getSlot)
                            .innerJoin(BigStorageCageDetails.class, BigStorageCageDetails::getGlassId, GlassInfo::getGlassId)
                            .eq(BigStorageCageDetails::getState, Const.GLASS_STATE_IN)
                            .eq(GlassInfo::getTemperingLayoutId, item.getTemperingLayoutId())
                            .eq(GlassInfo::getEngineerId, item.getEngineerId())
                            .orderBy(Boolean.TRUE, sequenceOrder, GlassInfo::getTemperingFeedSequence));
                    if (CollectionUtils.isNotEmpty(temperingGlassInfos)) {
                        temperingGlassInfoService.saveBatch(temperingGlassInfos);
                        computeOutGlassInfo(temperingGlassInfoList, Boolean.TRUE, mesToPLCAddress);
                        Date endDate = new Date();
                        log.info("大理片笼出片任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime());
                        return;
                    }
                }
            }
        }
        //未到齐 执行内部调度任务
        //执行内部调度任务
        TemperingLayoutDTO temperingOccupySlot = bigStorageCageDetailsService.queryTemperingOccupySlot();
        if (null != temperingOccupySlot) {
            List<SlotSequenceDTO> slotSequenceList = bigStorageCageDetailsService.queryGlassMaxAndMin(temperingOccupySlot.getEngineerId(), temperingOccupySlot.getTemperingLayoutId());
@@ -314,12 +319,25 @@
                SlotSequenceDTO second = slotSequenceList.get(i + 1);
                int slotWidth = carWidth - first.getRemainWidth() - glassGap;
                if (first.getMinSequence() == second.getMaxSequence() + 1
                        && second.getRemainWidth() > slotWidth) {
                        && second.getRemainWidth() > slotWidth && slotWidth >= 0) {

                    List<BigStorageCageDetails> list = bigStorageCageDetailsService.list(new LambdaQueryWrapper<BigStorageCageDetails>()
                            .eq(BigStorageCageDetails::getSlot, first.getSlot()).eq(BigStorageCageDetails::getState, Const.GLASS_STATE_IN));
                    List<BigStorageCageOutTask> outTasks = list.stream().map(e -> new BigStorageCageOutTask(e.getGlassId(), first.getSlot(), second.getSlot(),
                            e.getWidth() * 10, e.getHeight() * 10, 0, 0, 1)).collect(Collectors.toList());
                    bigStorageCageOutTaskService.saveBatch(outTasks);
                            .eq(BigStorageCageDetails::getSlot, first.getSlot()).eq(BigStorageCageDetails::getState, Const.GLASS_STATE_IN)
                            .orderBy(Boolean.TRUE, sequenceOrder, BigStorageCageDetails::getTemperingFeedSequence));
                    if (CollectionUtils.isNotEmpty(list)) {
                        List<BigStorageCageOutTask> outTasks = new ArrayList<>();
                        int serialNumber = 1;
                        for (BigStorageCageDetails item : list) {
                            outTasks.add(new BigStorageCageOutTask(item.getGlassId(), first.getSlot(), second.getSlot(),
                                    item.getWidth() * 10, item.getHeight() * 10, 1, serialNumber++, Const.BIG_STORAGE_OUT_NEW));
                        }
                        //新增调度任务
                        bigStorageCageOutTaskService.saveBatch(outTasks);
                        //更新理片笼详情表调度的后的玻璃位置信息：生成任务后先将玻璃格子位置进行调整，玻璃状态改为调度中，新增调度完成任务，处理调度完成后玻璃状态改为100.
                        List<String> glassList = list.stream().map(BigStorageCageDetails::getGlassId).collect(Collectors.toList());
                        bigStorageCageDetailsService.update(new LambdaUpdateWrapper<BigStorageCageDetails>().set(BigStorageCageDetails::getState, Const.GLASS_STATE_SCHEDULE_ING)
                                .set(BigStorageCageBaseInfo::getSlot, second.getSlot()).eq(BigStorageCageDetails::getGlassId, glassList));
                    }

                    //向plc写入确认字
                    int returnData = 0;
@@ -348,14 +366,18 @@
        if (CollectionUtils.isNotEmpty(list)) {
            log.info("2、获取所有正在进片的玻璃信息id:{}", list);
            List<String> glassIds = list.stream().map(String::valueOf).collect(Collectors.toList());
            List<Object> inSuccessGlassIdsObj = bigStorageCageFeedTaskService.listObjs(new LambdaQueryWrapper<BigStorageCageFeedTask>()
                    .select(BigStorageCageFeedTask::getGlassId).in(BigStorageCageFeedTask::getGlassId, glassIds)
            List<BigStorageCageFeedTask> inSuccessGlass = bigStorageCageFeedTaskService.list(new LambdaQueryWrapper<BigStorageCageFeedTask>()
                    .in(BigStorageCageFeedTask::getGlassId, glassIds)
                    .in(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_SLOT));
            List<String> inSuccessGlassIds = inSuccessGlassIdsObj.stream().map(String::valueOf).collect(Collectors.toList());
            if (CollectionUtils.isNotEmpty(inSuccessGlassIds)) {
                log.info("3、获取进片已完成的玻璃信息id:{}", inSuccessGlassIds);
                bigStorageCageDetailsService.update(new LambdaUpdateWrapper<BigStorageCageDetails>()
                        .set(BigStorageCageDetails::getState, Const.GLASS_STATE_IN).in(BigStorageCageDetails::getGlassId, inSuccessGlassIds));
            if (CollectionUtils.isNotEmpty(inSuccessGlass)) {
                log.info("3、获取进片已完成的玻璃信息id:{}", inSuccessGlass);
                List<String> inSuccessGlassIds = inSuccessGlass.stream().map(BigStorageCageFeedTask::getGlassId).collect(Collectors.toList());
                List<UpdateBigStorageCageDTO> storageCageDTOList = inSuccessGlass.stream().map(e -> {
                    UpdateBigStorageCageDTO storageCageDTO = new UpdateBigStorageCageDTO();
                    BeanUtils.copyProperties(e, storageCageDTO);
                    return storageCageDTO;
                }).collect(Collectors.toList());
                bigStorageCageDetailsService.updateBySlot(storageCageDTOList, Const.GLASS_STATE_IN);
                log.info("4、大理片笼进片状态已完成已完成的玻璃信息id:{}", inSuccessGlassIds);
                //更新理片笼玻璃尺寸
                updateSlotRemain(inSuccessGlassIds, Boolean.TRUE);
@@ -379,14 +401,19 @@
        if (CollectionUtils.isNotEmpty(list)) {
            log.info("2、获取所有正在出片的玻璃信息id:{}", list);
            List<String> glassIds = list.stream().map(String::valueOf).collect(Collectors.toList());
            List<Object> outSuccessGlassIdsObj = bigStorageCageOutTaskService.listObjs(new LambdaQueryWrapper<BigStorageCageOutTask>()
                    .select(BigStorageCageOutTask::getGlassId).in(BigStorageCageOutTask::getGlassId, glassIds).in(BigStorageCageOutTask::getTaskState, Const.BIG_STORAGE_OUT_ALL));
            List<String> outSuccessGlassIds = outSuccessGlassIdsObj.stream().map(String::valueOf).collect(Collectors.toList());
            if (CollectionUtils.isNotEmpty(outSuccessGlassIds)) {
                log.info("3、获取出片已完成的玻璃信息id:{}", outSuccessGlassIdsObj);
                bigStorageCageDetailsService.update(new LambdaUpdateWrapper<BigStorageCageDetails>()
                        .set(BigStorageCageDetails::getState, Const.GLASS_STATE_OUT).in(BigStorageCageDetails::getGlassId, outSuccessGlassIds));
                log.info("4、大理片笼出片状态已完成已完成的玻璃信息id:{}", outSuccessGlassIdsObj);
            List<BigStorageCageOutTask> outSuccessGlass = bigStorageCageOutTaskService.list(new LambdaQueryWrapper<BigStorageCageOutTask>()
                    .in(BigStorageCageOutTask::getGlassId, glassIds).in(BigStorageCageOutTask::getTaskState, Const.BIG_STORAGE_OUT_ALL));
            if (CollectionUtils.isNotEmpty(outSuccessGlass)) {
                log.info("3、获取出片已完成的玻璃信息id:{}", outSuccessGlass);
                List<UpdateBigStorageCageDTO> storageCageDTOList = outSuccessGlass.stream().map(e -> {
                    UpdateBigStorageCageDTO storageCageDTO = new UpdateBigStorageCageDTO();
                    storageCageDTO.setGlassId(e.getGlassId());
                    storageCageDTO.setTargetSlot(e.getStartSlot());
                    return storageCageDTO;
                }).collect(Collectors.toList());
                bigStorageCageDetailsService.updateBySlot(storageCageDTOList, Const.GLASS_STATE_OUT);
                List<String> outSuccessGlassIds = outSuccessGlass.stream().map(BigStorageCageOutTask::getGlassId).collect(Collectors.toList());
                log.info("4、大理片笼出片状态已完成已完成的玻璃信息id:{}", outSuccessGlassIds);
                //更新理片笼玻璃尺寸
                updateSlotRemain(outSuccessGlassIds, Boolean.FALSE);
                log.info("5、大理片笼进片目标格子尺寸更新完成");
@@ -624,6 +651,7 @@
        for (int i = 1; i <= taskList.size(); i++) {
            s7control.writeWord(plcMesObject.getPlcParameter("StartAddToImport" + i).getAddress(), taskList.get(i - 1).getLine());
            s7control.writeWord(plcMesObject.getPlcParameter("TargetAddToImport" + i).getAddress(), taskList.get(i - 1).getTargetSlot());
            log.info("向plc发送第{}片玻璃已完成", i);
        }
        int returnData = 0;
        int count = 1;
@@ -639,27 +667,36 @@
        List<BigStorageCageOutTask> bigStorageCageOutTaskList = new ArrayList<>();
        //打车剩余尺寸
        Integer remainWidth = carWidth;
        int trainNumber = 1;
        int serialNumber = 1;
        int maxX = 0;
        for (T e : list) {
            if (bigStorageCageOutTaskList.size() >= outCarMaxSize || e.getWidth() > remainWidth) {
                break;
            int maxLength = Math.max((int) e.getWidth(), (int) e.getHeight());
            if (bigStorageCageOutTaskList.size() >= outCarMaxSize || maxLength > remainWidth) {
                remainWidth = carWidth;
                trainNumber = trainNumber + 1;
                serialNumber = 1;
                maxX = 0;
                continue;
            }
            remainWidth = remainWidth - (int) e.getWidth() - glassGap;
            remainWidth = remainWidth - maxLength - glassGap;
            if (isTempering) {
                int minLength = Math.min((int) e.getWidth(), (int) e.getHeight());
                if (maxX + minLength <= xMaxSize) {
                    bigStorageCageOutTaskList.add(new BigStorageCageOutTask(e.getGlassId(), e.getSlot(), Const.TEMPERING_OUT_TARGET_POSITION,
                            e.getWidth() * 10, e.getHeight() * 10, 0, 0, 1));
                            e.getWidth() * 10, e.getHeight() * 10, trainNumber, serialNumber++, 1));
                    maxX = Math.max(maxX, e.getXCoordinate());
                } else {
                    break;
                    remainWidth = carWidth;
                    trainNumber = trainNumber + 1;
                    serialNumber = 1;
                    maxX = 0;
                    continue;
                }

            } else {
                bigStorageCageOutTaskList.add(new BigStorageCageOutTask(e.getGlassId(), e.getSlot(), Const.ARTIFICIAL_OUT_TARGET_POSITION,
                        e.getWidth() * 10, e.getHeight(), 0, 0, 1));
                        e.getWidth() * 10, e.getHeight(), trainNumber, serialNumber++, 1));
            }

        }
        Assert.isFalse(CollectionUtils.isEmpty(bigStorageCageOutTaskList), "未获取出片数据，结束出片任务");
        log.info("获取出片任务数据{}条，执行保存", bigStorageCageOutTaskList.size());
@@ -669,9 +706,6 @@
        bigStorageCageDetailsService.update(new LambdaUpdateWrapper<BigStorageCageDetails>()
                .set(BigStorageCageDetails::getState, Const.GLASS_STATE_OUT_ING)
                .in(BigStorageCageDetails::getGlassId, glassIds));
        //更新笼子内格子的剩余尺寸(移至出片任务完成后)
//        updateSlotRemain(list, glassIds);

        int returnData = 0;
        int count = 1;
        while (returnData == 0) {