1、卧理进出片订阅功能直接按订阅结果判断，订阅后查询数据库，可能造成数据重复读，任务重复执行问题 2、大理片笼新增任务表、任务历史表脚本 3、大理片笼...

zhoushihao

2024-11-12 9152c5394d4fd9d14d1a5fb9de9d441450b2bac6

1、卧理进出片订阅功能直接按订阅结果判断，订阅后查询数据库，可能造成数据重复读，任务重复执行问题
2、大理片笼新增任务表、任务历史表脚本
3、大理片笼进片任务功能开发已完成50%

 hangzhoumesParent/common/servicebase/src/main/java/com/mes/common/config/Const.java

@@ -244,5 +244,12 @@
    public static final Integer LOAD_RAW_GLASS_NEW = 0;
    public static final Integer LOAD_RAW_GLASS_SUCCESS = 100;

    /**
     * 大理片笼任务启动信号
     * 0 空任务
     * 1 启动
     */
    public static final Integer BIG_STORAGE_TASK_EMPTY = 0;
    public static final Integer BIG_STORAGE_TASK_RUNNING = 1;

}

 hangzhoumesParent/moduleService/CacheGlassModule/src/main/java/com/mes/job/opccallback/CacheGlassStartCallback.java

@@ -73,12 +73,13 @@
                log.info("任务表基础数据录入失败，请检查数据是否录入成功");
                return;
            }
            int request = task.getTaskState();
            int request = Integer.parseInt("" + value);
            log.info("开始执行任务，任务请信息为{}", task);
            if (request == 0) {
                log.info("未收到任务请求，结束本次任务");
            } else if (request == 1) {
                //进片任务
                log.info("进片任务：进片玻璃id为：{}", task.getGlassIdIn());
                intoTask(task, tableName);
            } else if (request == 2) {
                //出片任务
@@ -247,6 +248,7 @@
                        .eq(EdgStorageCageDetails::getState, Const.GLASS_STATE_IN)
                        .eq(EdgStorageCageDetails::getSlot, task.getCurrentCell()).eq(EdgStorageCageDetails::getWidth, edgStorageCageDetails.getWidth())
                        .eq(EdgStorageCageDetails::getHeight, edgStorageCageDetails.getHeight()).eq(EdgStorageCageDetails::getThickness, edgStorageCageDetails.getThickness())
                        .orderByAsc(EdgStorageCageDetails::getId).last("limit 1")
                );
                if (null != currentGlass) {
                    edgStorageCageDetails = currentGlass;
@@ -297,20 +299,16 @@
        Integer cell = task.getStartCell();
        Integer state = task.getTaskState();
        task.setTaskRunning(Const.GLASS_CACHE_TYPE_EMPTY);
//        task.setTaskState(Const.GLASS_CACHE_TYPE_EMPTY);
        task.setGlassIdOut("");
        task.setStartCell(0);
//        task.setWidth(0);
//        task.setHeight(0);
//        task.setThickness(0);
//        task.setFilmRemove(0);
        edgStorageDeviceTaskService.updateTaskMessage(tableName, task);
        edgStorageDeviceTaskHistoryService.update(new LambdaUpdateWrapper<EdgStorageDeviceTaskHistory>()
                .eq(EdgStorageDeviceTaskHistory::getTaskState, Const.RAW_GLASS_TASK_NEW)
                .set(EdgStorageDeviceTaskHistory::getTaskState,
                        Const.GLASS_CACHE_TYPE_FINISH.equals(state) ? Const.RAW_GLASS_TASK_SUCCESS : Const.RAW_GLASS_TASK_FAILURE)
        );
        updateCellRemainWidth(cell);
        int device = tableName.equals("edg_storage_device_one_task") ? 1 : 2;
        updateCellRemainWidth(cell, device);
        return Boolean.TRUE;
    }

@@ -426,7 +424,7 @@
        return Boolean.TRUE;
    }

    private boolean updateCellRemainWidth(int slot) {
    private boolean updateCellRemainWidth(int slot, int device) {
        List<EdgStorageCageDetails> list = edgStorageCageDetailsService.list(new LambdaQueryWrapper<EdgStorageCageDetails>().eq(EdgStorageCageDetails::getSlot, slot)
                .eq(EdgStorageCageDetails::getState, Const.GLASS_STATE_IN));
        int remainWidth = cellLength;
@@ -435,7 +433,7 @@
            remainWidth = cellLength - widthTotal >= 0 ? cellLength - widthTotal : 0;
        }
        edgStorageCageService.update(new LambdaUpdateWrapper<EdgStorageCage>().
                set(EdgStorageCage::getRemainWidth, remainWidth).eq(EdgStorageCage::getSlot, slot));
                set(EdgStorageCage::getRemainWidth, remainWidth).eq(EdgStorageCage::getSlot, slot).eq(EdgStorageCage::getDeviceId, device));
        return Boolean.TRUE;
    }
}

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

@@ -3,10 +3,11 @@
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.kangaroohy.milo.runner.subscription.SubscriptionCallback;
import com.kangaroohy.milo.service.MiloService;
import com.mes.bigstorage.entity.BigStorageCage;
import com.mes.bigstorage.entity.BigStorageCageDetails;
import com.mes.bigstorage.entity.BigStorageDTO;
import com.mes.bigstorage.service.BigStorageCageDetailsService;
import com.mes.bigstorage.service.BigStorageCageService;
import com.mes.bigstoragecageIntask.entity.BigStorageCageInTask;
import com.mes.bigstoragecageIntask.service.BigStorageCageInTaskService;
import com.mes.bigstoragetask.entity.BigStorageCageFeedTask;
@@ -17,20 +18,22 @@
import com.mes.common.config.Const;
import com.mes.damage.entity.Damage;
import com.mes.damage.service.DamageService;
import com.mes.glassinfo.entity.GlassInfo;
import com.mes.glassinfo.service.GlassInfoService;
import com.mes.temperingglass.entity.TemperingGlassInfo;
import com.mes.temperingglass.service.TemperingGlassInfoService;
import com.mes.tools.service.BigStorageBaseService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

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

/**
@@ -51,28 +54,39 @@
    private DamageService damageService;

    @Resource
    private GlassInfoService glassInfoService;
    @Resource
    private BigStorageCageService bigStorageCageService;

    @Resource
    private BigStorageBaseService baseService;
    @Resource
    private BigStorageCageInTaskService bigStorageBaseInTaskService;

    @Autowired(required = false)
    MiloService miloService;
    @Value("${mes.glassGap}")
    private Integer glassGap;

    @Resource(name = "bigStorageStartCallback")
    SubscriptionCallback bigStorageStartCallback;
//    @Resource
//    private BigStorageCage bigStorageBaseInTaskService;

//    @Autowired(required = false)
//    MiloService miloService;
//
//    @Resource(name = "bigStorageStartCallback")
//    SubscriptionCallback bigStorageStartCallback;


    @Scheduled(fixedDelay = Long.MAX_VALUE)
    public void startOpcTask() throws Exception {
        //设备一二的进片请求
        miloService.subscriptionFromOpcUa(Arrays.asList("my.device01.x1", "my.device02.x1"), bigStorageStartCallback);
    }
//    @Scheduled(fixedDelay = Long.MAX_VALUE)
//    public void startOpcTask() throws Exception {
//        //设备一二的进片请求
//        miloService.subscriptionFromOpcUa(Arrays.asList("my.device01.x1", "my.device02.x1"), bigStorageStartCallback);
//    }

    @Scheduled(fixedDelay = Long.MAX_VALUE)
    public void outOpcTask() throws Exception {
        //设备1的出片请求
        miloService.subscriptionFromOpcUa(Arrays.asList("my.device03.x1"), bigStorageStartCallback);
    }
//    @Scheduled(fixedDelay = Long.MAX_VALUE)
//    public void outOpcTask() throws Exception {
//        //设备1的出片请求
//        miloService.subscriptionFromOpcUa(Arrays.asList("my.device03.x1"), bigStorageStartCallback);
//    }


    @Scheduled(fixedDelay = 200)
@@ -82,7 +96,25 @@
        if (CollectionUtils.isEmpty(inTaskList)) {
            log.info("当前大车无进片任务，结束本地定时任务");
        }
        inTaskList
        List<String> glassIdList = inTaskList.stream().map(BigStorageCageInTask::getGlassId).collect(Collectors.toList());
        Map<String, List<BigStorageCageInTask>> taskMap = inTaskList.stream().collect(Collectors.groupingBy(BigStorageCageInTask::getGlassId));
        List<GlassInfo> glassInfoList = glassInfoService.list(new LambdaQueryWrapper<GlassInfo>().in(GlassInfo::getGlassId, glassIdList));
        //todo:计算目标格子
        for (GlassInfo info : glassInfoList) {
            //获取目标格子信息
            BigStorageDTO bigStorageDTO = bigStorageCageDetailsService.queryTargetSlotByTempering(info);
//            临时更新格子的剩余尺寸：防止相邻玻璃进同一格子造成剩余尺寸不足，玻璃越界的情况，任务完成后再次更新大理片笼表剩余宽度（按照笼内玻璃数量更新大理片笼剩余尺寸）
            bigStorageCageService.update(new LambdaUpdateWrapper<BigStorageCage>()
                    .set(BigStorageCage::getRemainWidth, bigStorageDTO.getWidth() - Math.max(info.getWidth(), info.getHeight()) - glassGap)
                    .eq(BigStorageCage::getSlot, bigStorageDTO.getSlot()));
            BigStorageCageInTask task = taskMap.get(info.getGlassId()).get(0);
            task.setTargetSlot(bigStorageDTO.getSlot());
            task.setGlassId(info.getGlassId());
            task.setTaskRunning(Const.BIG_STORAGE_TASK_RUNNING);
            bigStorageBaseInTaskService.updateTaskMessage("", task);
            //todo:存放历史任务
        }

    }



 hangzhoumesParent/moduleService/CacheVerticalGlassModule/src/main/resources/mapper/BigStorageCageInTaskMapper.xml

@@ -14,7 +14,7 @@
        select *
        from ${tableName}
        where glass_id is not null
           or glass_id = ''
           or glass_id != ''
    </select>

    <update id="updateTaskMessage">

 hangzhoumesParent/moduleService/LoadGlassModule/src/main/java/com/mes/uppattenusage/service/impl/UpPattenUsageServiceImpl.java

@@ -139,10 +139,15 @@
    @Override
    public Boolean updateGlassState(UpPattenUsage upPattenUsage) {
        UpdateWrapper<UpPattenUsage> updateWrapper = new UpdateWrapper<>();
        updateWrapper.eq("id",upPattenUsage.getId())
                .set("state",upPattenUsage.getState());
        updateWrapper.eq("id", upPattenUsage.getId())
                .set("state", upPattenUsage.getState());
        return this.update(updateWrapper);
    }

    @Override
    public Object Engineering(Engineering request) {
        return null;
    }


}

 hangzhoumesParent/moduleService/TemperingGlassModule/src/main/resources/changelog/ywChangelog.sql

@@ -170,4 +170,81 @@
    damage_count     int                DEFAULT '0' COMMENT '破损数量',
    PRIMARY KEY (id) USING BTREE
);
-- rollback DROP TABLE load_glass_device_task_history;
-- rollback DROP TABLE load_glass_device_task_history;

-- changeset zsh:20241112001
-- preconditions onFail:CONTINUE onError:CONTINUE
-- precondition-sql-check expectedResult:0 SELECT COUNT(*) FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME = 'big_storage_cage_in_history_task' and table_schema = 'hangzhoumes';
CREATE TABLE big_storage_cage_in_history_task
(
    id           BIGINT    NOT NULL AUTO_INCREMENT COMMENT '历史任务id',
    task_running INT                DEFAULT '0' COMMENT '任务请求 0无任务 1启动任务 2 确认完成',
    glass_id     VARCHAR(32) COMMENT '玻璃id',
    start_slot   INT                DEFAULT '0' COMMENT '起始格子',
    target_slot  INT                DEFAULT '0' COMMENT '目标格子',
    task_state   INT                DEFAULT NULL COMMENT '任务状态 ',
    create_time  TIMESTAMP NULL     DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
    task_type    TIMESTAMP NULL     DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
    update_time  TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
    PRIMARY KEY (id) USING BTREE
);
-- rollback DROP TABLE big_storage_cage_in_history_task;

-- changeset zsh:20241112002
-- preconditions onFail:CONTINUE onError:CONTINUE
-- precondition-sql-check expectedResult:0 SELECT COUNT(*) FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME = 'big_storage_cage_in_one_task' and table_schema = 'hangzhoumes';
CREATE TABLE big_storage_cage_in_one_task
(
    task_running INT DEFAULT '0' COMMENT '任务请求 0无任务 1启动任务 2 确认完成',
    glass_id     VARCHAR(32) COMMENT '玻璃id',
    start_slot   INT DEFAULT '0' COMMENT '起始格子',
    target_slot  INT DEFAULT '0' COMMENT '目标格子',
    task_state   INT DEFAULT NULL COMMENT '任务状态 '
);
-- rollback DROP TABLE big_storage_cage_in_one_task;

-- changeset zsh:20241112003
-- preconditions onFail:CONTINUE onError:CONTINUE
-- precondition-sql-check expectedResult:0 SELECT COUNT(*) FROM big_storage_cage_in_one_task;
INSERT INTO big_storage_cage_in_one_task(task_running, glass_id, start_slot, target_slot, task_state)
VALUES (0, NULL, 0, 0, 0);
INSERT INTO big_storage_cage_in_one_task(task_running, glass_id, start_slot, target_slot, task_state)
VALUES (0, NULL, 0, 0, 0);
INSERT INTO big_storage_cage_in_one_task(task_running, glass_id, start_slot, target_slot, task_state)
VALUES (0, NULL, 0, 0, 0);
INSERT INTO big_storage_cage_in_one_task(task_running, glass_id, start_slot, target_slot, task_state)
VALUES (0, NULL, 0, 0, 0);
INSERT INTO big_storage_cage_in_one_task(task_running, glass_id, start_slot, target_slot, task_state)
VALUES (0, NULL, 0, 0, 0);
INSERT INTO big_storage_cage_in_one_task(task_running, glass_id, start_slot, target_slot, task_state)
VALUES (0, NULL, 0, 0, 0);


-- changeset zsh:20241112004
-- preconditions onFail:CONTINUE onError:CONTINUE
-- precondition-sql-check expectedResult:0 SELECT COUNT(*) FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME = 'big_storage_cage_in_two_task' and table_schema = 'hangzhoumes';
CREATE TABLE big_storage_cage_in_two_task
(
    task_running INT DEFAULT '0' COMMENT '任务请求 0无任务 1启动任务 2 确认完成',
    glass_id     VARCHAR(32) COMMENT '玻璃id',
    start_slot   INT DEFAULT '0' COMMENT '起始格子',
    target_slot  INT DEFAULT '0' COMMENT '目标格子',
    task_state   INT DEFAULT NULL COMMENT '任务状态 '
);
-- rollback DROP TABLE big_storage_cage_in_two_task;
-- changeset zsh:20241112005
-- preconditions onFail:CONTINUE onError:CONTINUE
-- precondition-sql-check expectedResult:0 SELECT COUNT(*) FROM big_storage_cage_in_two_task;
INSERT INTO big_storage_cage_in_two_task(task_running, glass_id, start_slot, target_slot, task_state)
VALUES (0, NULL, 0, 0, 0);
INSERT INTO big_storage_cage_in_two_task(task_running, glass_id, start_slot, target_slot, task_state)
VALUES (0, NULL, 0, 0, 0);
INSERT INTO big_storage_cage_in_two_task(task_running, glass_id, start_slot, target_slot, task_state)
VALUES (0, NULL, 0, 0, 0);
INSERT INTO big_storage_cage_in_two_task(task_running, glass_id, start_slot, target_slot, task_state)
VALUES (0, NULL, 0, 0, 0);
INSERT INTO big_storage_cage_in_two_task(task_running, glass_id, start_slot, target_slot, task_state)
VALUES (0, NULL, 0, 0, 0);
INSERT INTO big_storage_cage_in_two_task(task_running, glass_id, start_slot, target_slot, task_state)
VALUES (0, NULL, 0, 0, 0);