1、opc订阅服务同时订阅一个节点两次，仅一个订阅任务生效，将进出片任务/完成任务放在一起 2、移除原片仓储中的下发字段

zhoushihao

2024-10-31 6abae920ad543ebdc3ee2e386828dd65e4c5ec35

 hangzhoumesParent/moduleService/GlassStorageModule/src/main/java/com/mes/job/RawGlassTask.java

@@ -2,15 +2,14 @@

import cn.hutool.core.collection.CollectionUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.kangaroohy.milo.model.ReadWriteEntity;
import com.kangaroohy.milo.service.MiloService;
import com.mes.common.config.Const;
import com.mes.engineering.entity.Engineering;
import com.mes.engineering.mapper.EngineeringMapper;
import com.mes.milo.model.ReadWriteEntity;
import com.mes.milo.service.MiloService;
import com.mes.rawglassdetails.entity.RawGlassStorageDetails;
import com.mes.rawglassdetails.service.RawGlassStorageDetailsService;
import com.mes.rawglassstation.entity.RawGlassStorageStation;
import com.mes.rawglassstation.service.RawGlassStorageStationService;
import com.mes.rawglasstask.entity.RawGlassStorageTask;
import com.mes.rawglasstask.service.RawGlassStorageTaskService;
import com.mes.uppattenusage.entity.vo.UpPattenUsageVO;
@@ -22,10 +21,7 @@
import org.springframework.util.CollectionUtils;

import javax.annotation.Resource;
import java.util.Arrays;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.*;
import java.util.stream.Collectors;

/**
@@ -38,8 +34,6 @@
public class RawGlassTask {

    @Autowired
    private RawGlassStorageStationService rawGlassStorageStationService;
    @Autowired
    private RawGlassStorageDetailsService rawGlassStorageDetailsService;

    @Autowired
@@ -50,152 +44,439 @@
    @Resource
    private UpPattenUsageMapper upPattenUsageMapper;

    @Autowired
    @Autowired(required = false)
    private MiloService miloService;

    private static final List<String> liftingStation = Arrays.asList("1", "2");
    private static final List<String> loadGlassStation = Arrays.asList("3", "4", "5", "6");
    private static final List<Integer> LIFTING_STATION = Arrays.asList(4);
    private static final List<String> LOAD_STATION_01 = Arrays.asList("101", "102");
    private static final List<String> LOAD_STATION_02 = Arrays.asList("103", "104");
    private static final List<Integer> LOAD_STATION_MAX = Arrays.asList(102, 104);
    private static final Integer LEFTING_01 = 98;
    private static final Integer LEFTING_02 = 99;
    private static final Integer LOAD_GLASS_01_01 = 101;
    private static final Integer LOAD_GLASS_01_02 = 102;
    private static final Integer LOAD_GLASS_02_01 = 103;
    private static final Integer LOAD_GLASS_02_02 = 104;

    @Scheduled(fixedDelay = 1000)
    public void rawStorageTask() throws Exception {
        ReadWriteEntity requestWord = miloService.readFromOpcUa("A01-CC.dev.request");
        ReadWriteEntity confireWord = miloService.readFromOpcUa("A01-CC.dev.confirmationWord");
        ReadWriteEntity reportWord = miloService.readFromOpcUa("A01-CC.dev.reportWord");
        ReadWriteEntity taskWord = miloService.readFromOpcUa("A01-CC.dev.taskWord");
        String requestValue = requestWord.getValue() + "";
        if ("0".equals(requestValue)) {
            if ("1".equals(confireWord.getValue() + "") && "0".equals(reportWord.getValue() + "")) {
                List<ReadWriteEntity> list = new ArrayList<>();
                list.add(generateReadWriteEntity("A01-CC.dev.confirmationWord", 0));
                miloService.writeToOpcWord(list);
            }
            if ("1".equals(taskWord.getValue() + "")) {
                List<ReadWriteEntity> list = new ArrayList<>();
                list.add(generateReadWriteEntity("A01-CC.dev.taskWord", 0));
//                list.add(generateReadWriteEntity("A01-CC.dev.taskSending", 0));
                list.add(generateReadWriteEntity("A01-CC.dev.startSlot", 0));
                list.add(generateReadWriteEntity("A01-CC.dev.endSlot", 0));
                miloService.writeToOpcWord(list);
            }
            return;
        }
        if (!"1".equals(requestValue)) {
            log.info("无请求");
            return;
        }
        //是否有正在执行的任务
        boolean flag = isHasRunningTask();
        if (flag) {
            log.info("有未完成的任务，结束");
            return;
        }
        //todo:优先进上片机位
        flag = rawGlassDispatchTask();
        if (flag) {
            log.info("执行调度任务，结束");
            return;
        }
        flag = outboundTask();
        if (flag) {
            log.info("执行出库任务，结束");
            return;
        }
        flag = warehouseTask();
        if (flag) {
            log.info("执行入库任务");
            return;
        }
        log.info("无任务执行，结束");
    }

    @Scheduled(fixedDelay = 1000)
    public void rawStorageInCar() throws Exception {
        ReadWriteEntity entity = miloService.readFromOpcUa("A01-CC.dev.inCar");
        String value = entity.getValue() + "";
        if (!"1".equals(value)) {
            log.info("大车上没有架子");
            return;
        }
        //查询任务
        RawGlassStorageDetails one = rawGlassStorageDetailsService.getOne(new LambdaQueryWrapper<RawGlassStorageDetails>()
                .eq(RawGlassStorageDetails::getState, Const.RAW_GLASS_STATE_RUNNING));
        if (one == null) {
            log.info("没有正在执行的任务");
            return;
        }
        rawGlassStorageDetailsService.update(new LambdaUpdateWrapper<RawGlassStorageDetails>().eq(RawGlassStorageDetails::getId, one.getId())
                .set(RawGlassStorageDetails::getState, Const.RAW_GLASS_STATE_CAR));

    }

    @Scheduled(fixedDelay = 1000)
    public void rawStorageFinish() throws Exception {
        ReadWriteEntity entity = miloService.readFromOpcUa("A01-CC.dev.reportWord");
        String value = entity.getValue() + "";
        if ("0".equals(value)) {
            log.info("当前任务未汇报，结束本次任务");
            return;
        }
        RawGlassStorageDetails details = rawGlassStorageDetailsService.getOne(new LambdaUpdateWrapper<RawGlassStorageDetails>()
                .eq(RawGlassStorageDetails::getState, Const.RAW_GLASS_STATE_CAR));
        if (null == details) {
            log.info("无执行中的任务");
            return;
        }
        RawGlassStorageTask task = rawGlassStorageTaskService.getOne(new LambdaQueryWrapper<RawGlassStorageTask>()
                .in(RawGlassStorageTask::getTaskState, Const.RAW_GLASS_TASK_NEW));
        RawGlassStorageDetails targetDetails = generateDetails(details, task.getEndSlot());
        Integer taskType = task.getTaskType();
        if ("1".equals(value)) {
            log.info("将详情表的状态改为已出库");
            rawGlassStorageDetailsService.update(new LambdaUpdateWrapper<RawGlassStorageDetails>()
                    .set(RawGlassStorageDetails::getState, Const.RAW_GLASS_STATE_OUT)
                    .eq(RawGlassStorageDetails::getSlot, task.getStartSlot()).eq(RawGlassStorageDetails::getState, Const.RAW_GLASS_STATE_CAR));
            log.info("任务状态已更改为：已完成");
            rawGlassStorageTaskService.update(new LambdaUpdateWrapper<RawGlassStorageTask>()
                    .eq(RawGlassStorageTask::getTaskState, Const.RAW_GLASS_TASK_NEW)
                    .set(RawGlassStorageTask::getTaskState, Const.RAW_GLASS_TASK_SUCCESS));
            switch (taskType) {
                case 1:
                    log.info("1、入库，3、调度任务。{}", taskType);
                    if (targetDetails.getRemainQuantity() > 0) {
                        rawGlassStorageDetailsService.save(targetDetails);
                    }
                    break;
                case 2:
                case 4:
                    log.info("2、出片,4、入库请求。{}", taskType);
                    targetDetails = new RawGlassStorageDetails();
                    targetDetails.setSlot(task.getEndSlot());
                    targetDetails.setShelf(task.getStartSlot());
                    targetDetails.setState(Const.RAW_GLASS_STATE_IN);
                    rawGlassStorageDetailsService.save(targetDetails);
                    break;
                default:
                    break;
            }
        } else {
            if (taskType.equals(Const.RAW_GLASS_TASK_TYPE_IN_REQUEST)) {
                rawGlassStorageDetailsService.update(new LambdaUpdateWrapper<RawGlassStorageDetails>()
                        .set(RawGlassStorageDetails::getState, Const.RAW_GLASS_STATE_OUT)
                        .eq(RawGlassStorageDetails::getSlot, task.getStartSlot())
                        .in(RawGlassStorageDetails::getState, Const.RAW_GLASS_STATE_RUNNING, Const.RAW_GLASS_STATE_CAR));
            } else {
                rawGlassStorageDetailsService.update(new LambdaUpdateWrapper<RawGlassStorageDetails>()
                        .set(RawGlassStorageDetails::getState, Const.RAW_GLASS_STATE_IN)
                        .eq(RawGlassStorageDetails::getSlot, task.getStartSlot())
                        .in(RawGlassStorageDetails::getState, Const.RAW_GLASS_STATE_RUNNING, Const.RAW_GLASS_STATE_CAR));
            }
            rawGlassStorageTaskService.update(new LambdaUpdateWrapper<RawGlassStorageTask>()
                    .eq(RawGlassStorageTask::getTaskState, Const.RAW_GLASS_TASK_NEW)
                    .set(RawGlassStorageTask::getTaskState, Const.RAW_GLASS_TASK_FAILURE));

        }
        List<ReadWriteEntity> list = new ArrayList<>();
        list.add(generateReadWriteEntity("A01-CC.dev.confirmationWord", 1));
        miloService.writeToOpcWord(list);
    }

    private boolean isHasRunningTask() {
        RawGlassStorageTask task = rawGlassStorageTaskService.getOne(new LambdaQueryWrapper<RawGlassStorageTask>()
                .in(RawGlassStorageTask::getTaskState, Const.RAW_GLASS_TASK_NEW));
        return task == null ? Boolean.FALSE : Boolean.TRUE;
    }

    /**
     * 原片调度：1、查询工程原片表，按照顺序将原片放入上片1号位，后续原片放上片2号位，出现尺寸替换，判断原上片位是否有玻璃，有 先出后进，无 直接进片
     */
    public boolean rawGlassDispatchTask() throws Exception {
        //查询当前系统正在执行的订单
        List<Engineering> engineeringList = engineeringMapper.selectList(new LambdaQueryWrapper<Engineering>()
                .eq(Engineering::getState, Const.ENGINEERING_RUNNING).last("order by id"));
        if (CollectionUtils.isEmpty(engineeringList)) {
            log.info("没有正在执行的工程");
            return false;
        }
        for (Engineering engineering : engineeringList) {
            boolean flag = rawGlassDispatchByEngineering(engineering.getStationCell(), engineering.getEngineerId());
            if (flag) {
                return flag;
            }
        }
        return Boolean.FALSE;


    }

    /**
     * 出库任务：1、点出库，立马生成出片任务 2、点出库修改工位详情内的状态为待出库，定时任务扫描生成出库任务
     */
    public boolean outboundTask() throws Exception {
        List<RawGlassStorageDetails> rawGlassList = rawGlassStorageDetailsService.list(new LambdaQueryWrapper<RawGlassStorageDetails>()
                .eq(RawGlassStorageDetails::getState, Const.RAW_GLASS_STATE_WAIT_OUT)
                .inSql(RawGlassStorageDetails::getSlot, "select slot from raw_glass_storage_station where enable_state = 1"));
        if (CollectionUtil.isEmpty(rawGlassList)) {
            log.info("系统没有需要出库的原片信息");
            return Boolean.FALSE;
        }
        //获取工位上是否有架子，
        List<RawGlassStorageDetails> emptyLeftingList = rawGlassStorageDetailsService.list(new LambdaQueryWrapper<RawGlassStorageDetails>()
                .in(RawGlassStorageDetails::getState, Const.RAW_GLASS_STATE_IN_ALL)
                .in(RawGlassStorageDetails::getSlot, "select slot from raw_glass_storage_station where enable_state = 1 and device_id = 4"));
        if (CollectionUtil.isNotEmpty(emptyLeftingList) && emptyLeftingList.size() > 1) {
            log.info("吊装位当前都有架子，结束出片任务");
            return Boolean.FALSE;
        }
        //获取需要落架的
        List<Integer> leftingList = emptyLeftingList.stream().map(RawGlassStorageDetails::getSlot).collect(Collectors.toList());
        int lefting = CollectionUtil.isEmpty(leftingList) ? LEFTING_01 : leftingList.get(0).equals(LEFTING_01) ? LEFTING_02 : LEFTING_01;
        Integer startSlot = rawGlassList.get(0).getSlot();
        //生成出库任务
        rawGlassStorageDetailsService.generateTask(startSlot, lefting, startSlot, rawGlassList.get(0).getRemainQuantity(), Const.RAW_GLASS_TASK_TYPE_OUT);

//        List<ReadWriteEntity> list = new ArrayList<>();
//        list.add(generateReadWriteEntity("A01-CC.dev.taskWord", 1));
//        list.add(generateReadWriteEntity("A01-CC.dev.taskSending", 1));
//        list.add(generateReadWriteEntity("A01-CC.dev.startSlot", startSlot));
//        list.add(generateReadWriteEntity("A01-CC.dev.endSlot", lefting));
//        miloService.writeToOpcWord(list);

        //修改出片任务状态
        rawGlassStorageDetailsService.update(new LambdaUpdateWrapper<RawGlassStorageDetails>()
                .eq(RawGlassStorageDetails::getSlot, rawGlassList.get(0).getSlot())
                .eq(RawGlassStorageDetails::getState, Const.RAW_GLASS_STATE_WAIT_OUT)
                .set(RawGlassStorageDetails::getState, Const.RAW_GLASS_STATE_RUNNING));
        return Boolean.TRUE;
    }

    /**
     * 入库任务：吊装位有玻璃，先去工位表查询空格子，生成入库任务从吊装位到目标格子
     *
     * @throws Exception
     */
    @Scheduled(fixedDelay = 1000)
    public void warehouseTask() throws Exception {
        ReadWriteEntity entity = miloService.readFromOpcUa("rawglass.device.request");
        String value = entity.getValueString();
        if (!"1".equals(value)) {
            log.info("大车忙碌");
            return;
        }
    public boolean warehouseTask() throws Exception {
        List<RawGlassStorageDetails> rawGlassList = rawGlassStorageDetailsService.list(new LambdaQueryWrapper<RawGlassStorageDetails>()
                .eq(RawGlassStorageDetails::getState, Const.GLASS_STATE_IN)
                .inSql(RawGlassStorageDetails::getSlotId, "select slot from raw_glass_storage_station where enable_state = 1 and slot in (1,2)"));
                .gt(RawGlassStorageDetails::getRemainQuantity, 0)
                .inSql(RawGlassStorageDetails::getSlot, "select slot from raw_glass_storage_station where enable_state = 1 and device_id = 4")
                .inSql(RawGlassStorageDetails::getShelf, "select slot from raw_glass_storage_station where enable_state = 1 "));
        if (CollectionUtil.isEmpty(rawGlassList)) {
            log.info("吊装位被禁用或没有玻璃");
            return;
        }
        //查询工位信息是否有
        List<RawGlassStorageStation> stationList = rawGlassStorageStationService.list(new LambdaQueryWrapper<RawGlassStorageStation>().notInSql(RawGlassStorageStation::getSlot, "select slot_id from raw_glass_storage_details where state = '100'")
                .eq(RawGlassStorageStation::getEnableState, Const.SLOT_ON));
        if (CollectionUtil.isEmpty(stationList)) {
            log.info("没有空的工位");
            return;
            log.info("吊装位被禁用/架子所在工位被禁用/无原片信息");
            return Boolean.FALSE;
        }
        //生成进笼任务
        generateTask(rawGlassList.get(0).getSlotId(), stationList.get(0).getSlot(),
                rawGlassList.get(0).getRemainQuantity(), Const.RAW_GLASS_TASK_TYPE_IN);
        RawGlassStorageDetails details = rawGlassList.get(0);
        rawGlassStorageDetailsService.generateTask(details.getSlot(), details.getShelf(), details.getShelf(),
                details.getRemainQuantity(), Const.RAW_GLASS_TASK_TYPE_IN);
//        List<ReadWriteEntity> list = new ArrayList<>();
//        list.add(generateReadWriteEntity("A01-CC.dev.taskWord", 1));
//        list.add(generateReadWriteEntity("A01-CC.dev.taskSending", 1));
//        list.add(generateReadWriteEntity("A01-CC.dev.startSlot", details.getSlot()));
//        list.add(generateReadWriteEntity("A01-CC.dev.endSlot", details.getShelf()));
//        miloService.writeToOpcWord(list);
        //生成工位任务，将吊装位的玻璃状态改位进笼中
    }


    /**
     * 出库任务：1、点出库，立马生成出片任务 2、点出库修改工位详情内的状态为待出库，定时任务扫描生成出库任务
     */
    @Scheduled(fixedDelay = 1000)
    public void outboundTask() throws Exception {
        ReadWriteEntity entity = miloService.readFromOpcUa("rawglass.device.request");
        String value = entity.getValueString();
        if (!"2".equals(value)) {
            log.info("大车忙碌");
            return;
        }
        List<RawGlassStorageDetails> rawGlassList = rawGlassStorageDetailsService.list(new LambdaQueryWrapper<RawGlassStorageDetails>()
                .eq(RawGlassStorageDetails::getState, Const.GLASS_STATE_OUT_ING)
                .inSql(RawGlassStorageDetails::getSlotId, "select slot from raw_glass_storage_station where enable_state = 1 and slot not in (1,2)"));
        if (CollectionUtil.isEmpty(rawGlassList)) {
            log.info("系统没有需要出库的原片信息");
            return;
        }
        List<Integer> emptyLeftingList = rawGlassStorageDetailsService.listBySlotState(liftingStation, Arrays.asList(Const.GLASS_STATE_IN));
        if (CollectionUtil.isEmpty(emptyLeftingList)) {
            log.info("吊装位当前都有原片，结束出片任务");
        }
        //生成出库任务
        generateTask(rawGlassList.get(0).getSlotId(), emptyLeftingList.get(0),
                rawGlassList.get(0).getRemainQuantity(), Const.RAW_GLASS_TASK_TYPE_OUT);
        //修改吊装位的原片状态为103 出片中
        //修改出片任务状态
        rawGlassStorageDetailsService.update(new LambdaUpdateWrapper<RawGlassStorageDetails>()
                .eq(RawGlassStorageDetails::getSlot, rawGlassList.get(0).getSlot())
                .eq(RawGlassStorageDetails::getState, Const.GLASS_STATE_IN)
                .set(RawGlassStorageDetails::getState, Const.RAW_GLASS_STATE_RUNNING));
        return Boolean.TRUE;
    }

    /**
     * 原片调度：1、查询工程原片表，按照顺序将原片放入上片1号位，后续原片放上片2号位，出现尺寸替换，判断原上片位是否有玻璃，有 先出后进，无 直接进片
     * @param stationCell 设备信息  5  、 6
     * @param enginneerId 共亨号
     * @return
     * @throws Exception
     */
    @Scheduled(fixedDelay = 1000)
    public void rawGlassDispatchTask() throws Exception {
        ReadWriteEntity entity = miloService.readFromOpcUa("rawglass.device.request");
        String value = entity.getValueString();
        if (!"2".equals(value)) {
            log.info("大车忙碌");
            return;
        }
        //查询当前系统正在执行的订单
        Engineering engineering = engineeringMapper.selectOne(new LambdaQueryWrapper<Engineering>().eq(Engineering::getState, Const.ENGINEERING_RUNNING).last("order by id limit 1"));
        if (null == engineering) {
            log.info("没有正在执行的工程");
            return;
        }
    private boolean rawGlassDispatchByEngineering(int stationCell, String enginneerId) throws Exception {
        //当前尺寸需要上片的数量
        List<UpPattenUsageVO> pattenUsageList = upPattenUsageMapper.queryRawGlassByEngineeringId(engineering.getEngineerId());
        List<UpPattenUsageVO> pattenUsageList = upPattenUsageMapper.queryRawGlassByEngineeringId(enginneerId);
        if (CollectionUtils.isEmpty(pattenUsageList)) {
            log.info("正在执行的工程原片无可上片的原片信息");
            return Boolean.FALSE;
        }
        //获取当前上片位1号架子信息
        int endSlot = stationCell == LOAD_GLASS_01_01 ? LOAD_GLASS_01_01 : LOAD_GLASS_02_01;
        int endSlot02 = stationCell == LOAD_GLASS_01_02 ? LOAD_GLASS_01_01 : LOAD_GLASS_02_02;
        Map<String, List<UpPattenUsageVO>> upListMap = pattenUsageList.stream()
                .collect(Collectors.groupingBy(UpPattenUsageVO::getGroupNumber));
        //todo:按照工程号按照工程下未完成的尺寸的顺序，当1号上片位架子上的当前尺寸玻璃少于3片且2号上片位无原片玻璃，则将去调度玻璃去2号上片位，
        //todo:当一号上片位架子上的玻璃位空或者当前尺寸用完时时，将2号（有玻璃）上片位调度到1号上片位
        //1、查询4个上片的原片详情
        //1、查询2个上片的原片详情
        List<RawGlassStorageDetails> rawGlassDetailsList = rawGlassStorageDetailsService.list(new LambdaQueryWrapper<RawGlassStorageDetails>()
                .eq(RawGlassStorageDetails::getState, Const.GLASS_STATE_IN).in(RawGlassStorageDetails::getSlotId, loadGlassStation));
                .eq(RawGlassStorageDetails::getState, Const.GLASS_STATE_IN).in(RawGlassStorageDetails::getDeviceId, stationCell)
                .orderByAsc(RawGlassStorageDetails::getSlot));
        List<UpPattenUsageVO> upPattenUsage01VOS = upListMap.get("1");
        UpPattenUsageVO usageVO = upPattenUsage01VOS.get(0);
        if (CollectionUtils.isEmpty(rawGlassDetailsList)) {
            //表示1上片位没有原片，直接找原片放入对应的上片位
            //结束调度任务
            //表示1上片位没有架子，直接找原片放入对应路线的1号上片位
            RawGlassStorageDetails details = rawGlassStorageDetailsService.getOne(new LambdaQueryWrapper<RawGlassStorageDetails>()
                            .eq(RawGlassStorageDetails::getFilmsId, usageVO.getFilmsId())
                            .eq(RawGlassStorageDetails::getPatternWidth, usageVO.getWidth())
                            .eq(RawGlassStorageDetails::getPatternHeight, usageVO.getHeight())
                            .eq(RawGlassStorageDetails::getPatternThickness, usageVO.getThickness())
                            .inSql(RawGlassStorageDetails::getSlot, "select slot from raw_glass_storage_station where enable_state = 1")
                            .eq(RawGlassStorageDetails::getState, Const.RAW_GLASS_STATE_IN)
//                    .gt(RawGlassStorageDetails::getRemainQuantity, upPattenUsage01VOS.size())
                            .orderByAsc(RawGlassStorageDetails::getRemainQuantity)
                            .last("limit 1")
            );
            rawGlassStorageDetailsService.generateTask(details.getSlot(), endSlot, details.getSlot(), details.getRemainQuantity(), Const.RAW_GLASS_TASK_TYPE_DISPATCH);

            //结束调度任务 修改工位状态(起始位）状态为103 RAW_GLASS_STATE_RUNNING 任务完成后将状态改为101  目标位新增一条数据，架子号为（起始位）
            rawGlassStorageDetailsService.update(new LambdaUpdateWrapper<RawGlassStorageDetails>()
                    .eq(RawGlassStorageDetails::getSlot, details.getSlot()).eq(RawGlassStorageDetails::getState, Const.RAW_GLASS_STATE_IN)
                    .set(RawGlassStorageDetails::getDeviceId, Const.RAW_GLASS_STATE_RUNNING));
            return Boolean.TRUE;
        }
        Map<Integer, List<RawGlassStorageDetails>> listMap = rawGlassDetailsList.stream().collect(Collectors.groupingBy(RawGlassStorageDetails::getSlotId));
        RawGlassStorageDetails rawGlass03Details = listMap.get(3).get(0);
        RawGlassStorageDetails rawGlass04Details = listMap.get(4).get(0);
//        RawGlassStorageDetails rawGlass05Details = listMap.get(5).get(0);
//        RawGlassStorageDetails rawGlass06Details = listMap.get(6).get(0);
        //todo:上片1号位2种清空方式：方式一：原片用完  方式二：当前尺寸用完
        if (null == rawGlass03Details) {
            if (null == rawGlass04Details) {
                //表示1上片位没有原片，直接找原片放入对应的上片位
                //结束调度任务
            } else {
                //将2号上片位的原片放入1号上片位
                //结束调度任务
        RawGlassStorageDetails glassStorageDetails = rawGlassDetailsList.get(0);
        if (rawGlassDetailsList.size() == 2) {
            if (!((usageVO.getWidth() == glassStorageDetails.getPatternWidth() && usageVO.getHeight() == glassStorageDetails.getPatternHeight() &&
                    usageVO.getThickness() == glassStorageDetails.getPatternThickness() && usageVO.getFilmsId().equals(glassStorageDetails.getFilmsId())))
                    || ((usageVO.getWidth() == glassStorageDetails.getPatternWidth() && usageVO.getHeight() == glassStorageDetails.getPatternHeight() &&
                    usageVO.getThickness() == glassStorageDetails.getPatternThickness() && usageVO.getFilmsId().equals(glassStorageDetails.getFilmsId()))
                    && glassStorageDetails.getRemainQuantity() == 0)) {
                //将架子放回原工位上
                rawGlassStorageDetailsService.generateTask(endSlot, glassStorageDetails.getShelf(), glassStorageDetails.getShelf(), 0, Const.RAW_GLASS_TASK_TYPE_DISPATCH);
//                List<ReadWriteEntity> list = new ArrayList<>();
//                list.add(generateReadWriteEntity("A01-CC.dev.taskWord", 1));
//                list.add(generateReadWriteEntity("A01-CC.dev.taskSending", 1));
//                list.add(generateReadWriteEntity("A01-CC.dev.startSlot", endSlot));
//                list.add(generateReadWriteEntity("A01-CC.dev.endSlot", glassStorageDetails.getShelf()));
//                miloService.writeToOpcWord(list);
                rawGlassStorageDetailsService.update(new LambdaUpdateWrapper<RawGlassStorageDetails>()
                        .eq(RawGlassStorageDetails::getSlot, glassStorageDetails.getSlot()).eq(RawGlassStorageDetails::getState, Const.RAW_GLASS_STATE_IN)
                        .set(RawGlassStorageDetails::getState, Const.RAW_GLASS_STATE_RUNNING));
                return Boolean.TRUE;
            }
            return Boolean.FALSE;
        }
        //todo:1条线且当条线为2号上片为
        if (LOAD_STATION_MAX.contains(glassStorageDetails.getSlot())) {
            log.info("上片位2号有架子，结束本条线{}的调度任务", stationCell);
            if (!((usageVO.getWidth() == glassStorageDetails.getPatternWidth() && usageVO.getHeight() == glassStorageDetails.getPatternHeight() &&
                    usageVO.getThickness() == glassStorageDetails.getPatternThickness() && usageVO.getFilmsId().equals(glassStorageDetails.getFilmsId())))
                    || ((usageVO.getWidth() == glassStorageDetails.getPatternWidth() && usageVO.getHeight() == glassStorageDetails.getPatternHeight() &&
                    usageVO.getThickness() == glassStorageDetails.getPatternThickness() && usageVO.getFilmsId().equals(glassStorageDetails.getFilmsId()))
                    && glassStorageDetails.getRemainQuantity() == 0)) {
                //将架子放回原工位上
                rawGlassStorageDetailsService.generateTask(endSlot02, glassStorageDetails.getShelf(), glassStorageDetails.getShelf(), 0, Const.RAW_GLASS_TASK_TYPE_DISPATCH);
//                List<ReadWriteEntity> list = new ArrayList<>();
//                list.add(generateReadWriteEntity("A01-CC.dev.taskWord", 1));
//                list.add(generateReadWriteEntity("A01-CC.dev.taskSending", 1));
//                list.add(generateReadWriteEntity("A01-CC.dev.startSlot", endSlot02));
//                list.add(generateReadWriteEntity("A01-CC.dev.endSlot", glassStorageDetails.getShelf()));
//                miloService.writeToOpcWord(list);
                rawGlassStorageDetailsService.update(new LambdaUpdateWrapper<RawGlassStorageDetails>()
                        .eq(RawGlassStorageDetails::getSlot, glassStorageDetails.getSlot()).eq(RawGlassStorageDetails::getState, Const.RAW_GLASS_STATE_IN)
                        .set(RawGlassStorageDetails::getState, Const.RAW_GLASS_STATE_RUNNING));
                return Boolean.TRUE;
            }
            return Boolean.FALSE;
        } else {
            //原片剩余数量
            Integer quantity = rawGlass03Details.getRemainQuantity();
            List<UpPattenUsageVO> upPattenUsage01VOS = upListMap.get("1");
            if (null == rawGlass04Details) {
                //todo:判断2号上片位需要的原片信息
                if (quantity < upPattenUsage01VOS.size()) {
                    //todo:继续上一号上片位当前的尺寸
            //比较当前1号架子上的玻璃剩余数量是否为0或者已用完
            if (usageVO.getWidth() == glassStorageDetails.getPatternWidth() && usageVO.getHeight() == glassStorageDetails.getPatternHeight() &&
                    usageVO.getThickness() == glassStorageDetails.getPatternThickness() && usageVO.getFilmsId().equals(glassStorageDetails.getFilmsId())) {
                RawGlassStorageDetails details = null;
                if (upPattenUsage01VOS.size() > glassStorageDetails.getRemainQuantity()) {
                    //2号位上片：继续当前尺寸的原片
                    details = rawGlassStorageDetailsService.getOne(new LambdaQueryWrapper<RawGlassStorageDetails>()
                            .eq(RawGlassStorageDetails::getFilmsId, usageVO.getFilmsId())
                            .eq(RawGlassStorageDetails::getPatternWidth, usageVO.getWidth())
                            .eq(RawGlassStorageDetails::getPatternHeight, usageVO.getHeight())
                            .eq(RawGlassStorageDetails::getPatternThickness, usageVO.getThickness())
                            .gt(RawGlassStorageDetails::getRemainQuantity, upPattenUsage01VOS.size())
                            .orderByAsc(RawGlassStorageDetails::getRemainQuantity)
                            .last("limit 1"));
                } else {
                    //todo:切换尺寸，上后续组的尺寸
                    //2号位上片：获取第二种尺寸的原片
                    List<UpPattenUsageVO> upPattenUsage02VOS = upListMap.get("2");
                    if (CollectionUtils.isEmpty(upPattenUsage01VOS)) {
                        return Boolean.FALSE;
                    }
                    usageVO = upPattenUsage02VOS.get(0);
                    details = rawGlassStorageDetailsService.getOne(new LambdaQueryWrapper<RawGlassStorageDetails>()
                            .eq(RawGlassStorageDetails::getFilmsId, usageVO.getFilmsId())
                            .eq(RawGlassStorageDetails::getPatternWidth, usageVO.getWidth())
                            .eq(RawGlassStorageDetails::getPatternHeight, usageVO.getHeight())
                            .eq(RawGlassStorageDetails::getPatternThickness, usageVO.getThickness())
                            .gt(RawGlassStorageDetails::getRemainQuantity, upPattenUsage01VOS.size())
                            .orderByAsc(RawGlassStorageDetails::getRemainQuantity)
                            .last("limit 1"));
                }
                //将工位的架子传送到上片位
                rawGlassStorageDetailsService.generateTask(details.getSlot(), endSlot02, details.getShelf(), details.getRemainQuantity(), Const.RAW_GLASS_TASK_TYPE_DISPATCH);
                rawGlassStorageDetailsService.update(new LambdaUpdateWrapper<RawGlassStorageDetails>()
                        .eq(RawGlassStorageDetails::getSlot, details.getSlot()).eq(RawGlassStorageDetails::getState, Const.RAW_GLASS_STATE_IN)
                        .set(RawGlassStorageDetails::getDeviceId, Const.RAW_GLASS_STATE_RUNNING));

//                List<ReadWriteEntity> list = new ArrayList<>();
//                list.add(generateReadWriteEntity("A01-CC.dev.taskWord", 1));
//                list.add(generateReadWriteEntity("A01-CC.dev.taskSending", 1));
//                list.add(generateReadWriteEntity("A01-CC.dev.startSlot", glassStorageDetails.getShelf()));
//                list.add(generateReadWriteEntity("A01-CC.dev.endSlot", endSlot02));
//                miloService.writeToOpcWord(list);

                return Boolean.TRUE;
            } else {
                //将架子放回原工位上
                rawGlassStorageDetailsService.generateTask(endSlot, glassStorageDetails.getShelf(), glassStorageDetails.getShelf(), glassStorageDetails.getRemainQuantity(), Const.RAW_GLASS_TASK_TYPE_DISPATCH);
                rawGlassStorageDetailsService.update(new LambdaUpdateWrapper<RawGlassStorageDetails>()
                        .eq(RawGlassStorageDetails::getSlot, endSlot).eq(RawGlassStorageDetails::getState, Const.RAW_GLASS_STATE_IN)
                        .set(RawGlassStorageDetails::getDeviceId, Const.RAW_GLASS_STATE_RUNNING));

//                List<ReadWriteEntity> list = new ArrayList<>();
//                list.add(generateReadWriteEntity("A01-CC.dev.taskWord", 1));
//                list.add(generateReadWriteEntity("A01-CC.dev.taskSending", 1));
//                list.add(generateReadWriteEntity("A01-CC.dev.startSlot", endSlot));
//                list.add(generateReadWriteEntity("A01-CC.dev.endSlot", glassStorageDetails.getShelf()));
//                miloService.writeToOpcWord(list);
                return Boolean.TRUE;
            }
        }
    }

    private RawGlassStorageDetails generateDetails(RawGlassStorageDetails details, Integer targetSlot) {

        RawGlassStorageDetails targetDetails = new RawGlassStorageDetails();
//        details.setDeviceId();
        targetDetails.setSlot(targetSlot);
        targetDetails.setShelf(details.getShelf());
        targetDetails.setPatternWidth(details.getPatternWidth());
        targetDetails.setPatternHeight(details.getPatternHeight());
        targetDetails.setPatternThickness(details.getPatternThickness());
        targetDetails.setFilmsId(details.getFilmsId());
        targetDetails.setRemainQuantity(details.getRemainQuantity());
        targetDetails.setCreateTime(new Date());
        targetDetails.setState(Const.RAW_GLASS_STATE_IN);
        return targetDetails;
    }


    /**
     * 生成原片仓储任务
     *
     * @param startSlot
     * @param endSlot
     * @param patternQuantity
     * @param taskType
     * @return
     */
    private boolean generateTask(int startSlot, int endSlot, Integer patternQuantity, int taskType) {
        RawGlassStorageTask task = RawGlassStorageTask.builder()
                .originateSlot(startSlot)
                .endSlot(endSlot)
                .patternQuantity(patternQuantity)
                .taskType(taskType)
                .createTime(new Date()).build();
        return rawGlassStorageTaskService.save(task);
    private ReadWriteEntity generateReadWriteEntity(String identifier, int value) {
        ReadWriteEntity readWriteEntity = new ReadWriteEntity();
        readWriteEntity.setIdentifier(identifier);
        readWriteEntity.setValue(value);
        return readWriteEntity;
    }

}