#

Junjie

5 天以前 96cfc17f191fee0a05070ec8e7bb6fb099f0231c

 src/main/java/com/zy/core/plugin/FakeProcess.java

@@ -3,14 +3,13 @@
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.core.common.Cools;
import com.zy.asrs.domain.param.CreateInTaskParam;
import com.zy.asrs.domain.param.CreateOutTaskParam;
import com.zy.asrs.entity.*;
import com.zy.asrs.service.*;
import com.zy.asrs.utils.Utils;
import com.zy.common.model.StartupDto;
import com.zy.common.service.CommonService;
import com.zy.common.utils.HttpHandler;
import com.zy.common.utils.RedisUtil;
import com.zy.core.News;
import com.zy.core.cache.MessageQueue;
@@ -22,10 +21,12 @@
import com.zy.core.model.command.StationCommand;
import com.zy.core.model.protocol.CrnProtocol;
import com.zy.core.model.protocol.StationProtocol;
import com.zy.core.properties.SystemProperties;
import com.zy.core.thread.CrnThread;
import com.zy.core.thread.StationThread;
import com.zy.core.utils.CrnOperateProcessUtils;
import com.zy.core.utils.StationOperateProcessUtils;
import com.zy.core.utils.WmsOperateUtils;
import com.zy.system.entity.Config;
import com.zy.system.service.ConfigService;
import lombok.extern.slf4j.Slf4j;
@@ -41,6 +42,11 @@
    private static Map<Integer,Long> stationStayTimeMap = new HashMap<>();
    private static String enableFake = "N";
    private static String fakeRealTaskRequestWms = "N";
    private static String fakeGenerateInTask = "Y";
    private static String fakeGenerateOutTask = "Y";

    private Thread asyncRunThread = null;
    private Thread asyncFakeRunThread = null;

    @Autowired
    private WrkMastService wrkMastService;
@@ -61,35 +67,13 @@
    @Autowired
    private StationOperateProcessUtils stationOperateProcessUtils;
    @Autowired
    private HttpRequestLogService httpRequestLogService;
    private WmsOperateUtils wmsOperateUtils;

    @Override
    public void run() {
        Config enableFakeConfig = configService.selectOne(new EntityWrapper<Config>().eq("code", "enableFake"));
        if (enableFakeConfig != null) {
            enableFake = enableFakeConfig.getValue();
        }
        asyncRun();
        asyncFakeRun();

        Config fakeRealTaskRequestWmsConfig = configService.selectOne(new EntityWrapper<Config>().eq("code", "fakeRealTaskRequestWms"));
        if (fakeRealTaskRequestWmsConfig != null) {
            fakeRealTaskRequestWms = fakeRealTaskRequestWmsConfig.getValue();
        }

        //检测入库站是否有任务生成，并仿真生成模拟入库站点数据
        checkInStationHasTask();
        //生成仿真模拟入库任务
        generateFakeInTask();
        //生成仿真模拟出库任务
        generateFakeOutTask();
        //计算所有站点停留时间
        calcAllStationStayTime();
        //检测出库站点停留是否超时
        checkOutStationStayTimeOut();
        //检测入库站点堆垛机是否取走货物
        checkInStationCrnTake();

        //请求生成入库任务
        generateStoreWrkFile();
        //执行堆垛机任务
        crnOperateUtils.crnIoExecute();
        //堆垛机任务执行完成-具备仿真能力
@@ -102,9 +86,108 @@
        stationOperateProcessUtils.stationOutExecuteFinish();
    }

    public void asyncRun() {
        if (asyncRunThread != null) {
            return;
        }

        asyncRunThread = new Thread(() -> {
            while (!Thread.currentThread().isInterrupted()) {
                try {
                    // 系统运行状态判断
                    if (!SystemProperties.WCS_RUNNING_STATUS.get()) {
                        continue;
                    }

                    //请求生成入库任务
                    generateStoreWrkFile();

                    // 间隔
                    Thread.sleep(50);
                } catch (InterruptedException ie) {
                    Thread.currentThread().interrupt();
                    break;
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });
        asyncRunThread.setName("asyncRunProcess");
        asyncRunThread.setDaemon(true);
        asyncRunThread.start();
    }

    public void asyncFakeRun() {
        if (asyncFakeRunThread != null) {
            return;
        }

        asyncFakeRunThread = new Thread(() -> {
            while (!Thread.currentThread().isInterrupted()) {
                try {
                    Config enableFakeConfig = configService.selectOne(new EntityWrapper<Config>().eq("code", "enableFake"));
                    if (enableFakeConfig != null) {
                        enableFake = enableFakeConfig.getValue();
                    }

                    Config fakeRealTaskRequestWmsConfig = configService.selectOne(new EntityWrapper<Config>().eq("code", "fakeRealTaskRequestWms"));
                    if (fakeRealTaskRequestWmsConfig != null) {
                        fakeRealTaskRequestWms = fakeRealTaskRequestWmsConfig.getValue();
                    }

                    Config fakeGenerateInTaskConfig = configService.selectOne(new EntityWrapper<Config>().eq("code", "fakeGenerateInTask"));
                    if (fakeGenerateInTaskConfig != null) {
                        fakeGenerateInTask = fakeGenerateInTaskConfig.getValue();
                    }

                    Config fakeGenerateOutTaskConfig = configService.selectOne(new EntityWrapper<Config>().eq("code", "fakeGenerateOutTask"));
                    if (fakeGenerateOutTaskConfig != null) {
                        fakeGenerateOutTask = fakeGenerateOutTaskConfig.getValue();
                    }

                    // 系统运行状态判断
                    if (!SystemProperties.WCS_RUNNING_STATUS.get()) {
                        continue;
                    }

                    //检测入库站是否有任务生成，并仿真生成模拟入库站点数据
                    checkInStationHasTask();
                    //生成仿真模拟入库任务
                    generateFakeInTask();
                    //生成仿真模拟出库任务
                    generateFakeOutTask();
                    //计算所有站点停留时间
                    calcAllStationStayTime();
                    //检测出库站点停留是否超时
                    checkOutStationStayTimeOut();
                    //检测入库站点堆垛机是否取走货物
                    checkInStationCrnTake();

                    //检测输送站点是否运行堵塞
                    stationOperateProcessUtils.checkStationRunBlock();

                    // 间隔
                    Thread.sleep(50);
                } catch (InterruptedException ie) {
                    Thread.currentThread().interrupt();
                    break;
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });
        asyncFakeRunThread.setName("asyncFakeRunProcess");
        asyncFakeRunThread.setDaemon(true);
        asyncFakeRunThread.start();
    }

    //检测入库站是否有任务生成，并仿真生成模拟入库站点数据
    private synchronized void checkInStationHasTask() {
        if (!enableFake.equals("Y")) {
            return;
        }

        if (!fakeGenerateInTask.equals("Y")) {
            return;
        }

@@ -129,8 +212,8 @@
                    continue;
                }

                Object object = redisUtil.get(RedisKeyType.GENERATE_FAKE_IN_STATION_DATA_LIMIT.key + stationId);
                if (object != null) {
                Object lock = redisUtil.get(RedisKeyType.GENERATE_FAKE_IN_STATION_DATA_LIMIT.key + stationId);
                if(lock != null){
                    continue;
                }

@@ -139,9 +222,9 @@
                        && !stationProtocol.isLoading()
                        && stationProtocol.getTaskNo() == 0
                ) {
                    StationCommand command = stationThread.getMoveCommand(9999, stationId, 0, 0);
                    StationCommand command = stationThread.getMoveCommand(commonService.getWorkNo(WrkIoType.FAKE_TASK_NO.id), stationId, entity.getBarcodeStation().getStationId(), 0);
                    MessageQueue.offer(SlaveType.Devp, basDevp.getDevpNo(), new Task(2, command));
                    redisUtil.set(RedisKeyType.GENERATE_FAKE_IN_STATION_DATA_LIMIT.key + stationId, "lock", 10);
                    redisUtil.set(RedisKeyType.GENERATE_FAKE_IN_STATION_DATA_LIMIT.key + stationId, "lock", 5);
                }
            }
        }
@@ -157,6 +240,10 @@
            return;
        }

        if (!fakeGenerateInTask.equals("Y")) {
            return;
        }

        List<BasDevp> basDevps = basDevpService.selectList(new EntityWrapper<>());
        for (BasDevp basDevp : basDevps) {
            StationThread stationThread = (StationThread) SlaveConnection.get(SlaveType.Devp, basDevp.getDevpNo());
@@ -166,7 +253,7 @@

            Map<Integer, StationProtocol> stationMap = stationThread.getStatusMap();

            List<StationObjModel> list = basDevp.getInStationList$();
            List<StationObjModel> list = basDevp.getBarcodeStationList$();
            for (StationObjModel model : list) {
                Integer stationId = model.getStationId();
                if(!stationMap.containsKey(stationId)){
@@ -180,14 +267,18 @@

                Object object = redisUtil.get(RedisKeyType.GENERATE_FAKE_IN_TASK_LIMIT.key + stationId);
                if (object != null) {
                    return;
                    continue;
                }

                //满足自动、有物、工作号9999，生成入库数据
                //满足自动、有物、有工作号，生成入库数据
                if (stationProtocol.isAutoing()
                        && stationProtocol.isLoading()
                        && stationProtocol.getTaskNo() == 9999
                        && stationProtocol.getTaskNo() > 0
                ) {
                    if (Cools.isEmpty(stationProtocol.getBarcode())) {
                        continue;
                    }

                    //检测任务是否生成
                    List<WrkMast> wrkMasts = wrkMastService.selectList(new EntityWrapper<WrkMast>().eq("barcode", stationProtocol.getBarcode()));
                    if (!wrkMasts.isEmpty()) {
@@ -218,8 +309,14 @@
                    taskParam.setStaNo(targetStationId);
                    taskParam.setLocNo(locMast.getLocNo());
                    taskParam.setBarcode(stationProtocol.getBarcode());
                    boolean result = commonService.createInTask(taskParam);
                    WrkMast wrkMast = commonService.createInTask(taskParam);

                    StationCommand command = stationThread.getMoveCommand(wrkMast.getWrkNo(), stationId, stationId, 0);
                    if(command == null){
                        News.taskInfo(wrkMast.getWrkNo(), "获取输送线命令失败");
                        continue;
                    }
                    MessageQueue.offer(SlaveType.Devp, basDevp.getDevpNo(), new Task(2, command));
                    redisUtil.set(RedisKeyType.GENERATE_FAKE_IN_TASK_LIMIT.key + stationId, "lock", 5);
                }
            }
@@ -233,6 +330,10 @@
        }

        if (fakeRealTaskRequestWms.equals("Y")) {
            return;
        }

        if (!fakeGenerateOutTask.equals("Y")) {
            return;
        }

@@ -284,7 +385,7 @@
                    taskParam.setStaNo(stationId);
                    taskParam.setLocNo(locMast.getLocNo());
                    boolean result = commonService.createOutTask(taskParam);
                    redisUtil.set(RedisKeyType.GENERATE_FAKE_OUT_TASK_LIMIT.key + stationId, "lock", 15);
                    redisUtil.set(RedisKeyType.GENERATE_FAKE_OUT_TASK_LIMIT.key + stationId, "lock", 10);
                }
            }
        }
@@ -308,7 +409,7 @@

            Map<Integer, StationProtocol> stationMap = stationThread.getStatusMap();

            List<StationObjModel> list = basDevp.getInStationList$();
            List<StationObjModel> list = basDevp.getBarcodeStationList$();
            for (StationObjModel entity : list) {
                Integer stationId = entity.getStationId();
                if(!stationMap.containsKey(stationId)){
@@ -320,84 +421,49 @@
                    continue;
                }

                //满足自动、有物、工作号9999，生成入库数据
                //满足自动、有物、有工作号，生成入库数据
                if (stationProtocol.isAutoing()
                        && stationProtocol.isLoading()
                        && stationProtocol.getTaskNo() == 9999
                        && stationProtocol.getTaskNo() > 0
                ) {
                    if (Cools.isEmpty(stationProtocol.getBarcode())) {
                        continue;
                    }

                    //检测任务是否生成
                    List<WrkMast> wrkMasts = wrkMastService.selectList(new EntityWrapper<WrkMast>().eq("barcode", stationProtocol.getBarcode()));
                    if (!wrkMasts.isEmpty()) {
                        continue;
                    }

                    String wmsUrl = null;
                    Config wmsSystemUriConfig = configService.selectOne(new EntityWrapper<Config>().eq("code", "wmsSystemUri"));
                    if (wmsSystemUriConfig != null) {
                        wmsUrl = wmsSystemUriConfig.getValue();
                    }

                    if(wmsUrl == null){
                        News.error("未配置WMS系统URI，配置文件Code编码：wmsSystemUri");
                        return;
                    }

                    String wmsSystemInUrl = null;
                    Config wmsSystemInUrlConfig = configService.selectOne(new EntityWrapper<Config>().eq("code", "wmsSystemInUrl"));
                    if (wmsSystemInUrlConfig != null) {
                        wmsSystemInUrl = wmsSystemInUrlConfig.getValue();
                    }

                    if(wmsSystemInUrlConfig == null){
                        News.error("未配置WMS入库接口地址，配置文件Code编码：wmsSystemInUrl");
                        return;
                    }

                    Object lock = redisUtil.get(RedisKeyType.GENERATE_IN_TASK_LIMIT.key + stationId);
                    if (lock != null) {
                        continue;
                    }
                    redisUtil.set(RedisKeyType.GENERATE_IN_TASK_LIMIT.key + stationId, "lock", 2);

                    redisUtil.set(RedisKeyType.GENERATE_IN_TASK_LIMIT.key + stationId, "lock", 15);
                    String response = wmsOperateUtils.applyInTask(stationProtocol.getBarcode(), stationProtocol.getStationId(), stationProtocol.getPalletHeight());
                    if (response == null) {
                        News.error("请求WMS入库接口失败，接口未响应！！！response：{}", response);
                        continue;
                    }
                    JSONObject jsonObject = JSON.parseObject(response);
                    if (jsonObject.getInteger("code").equals(200)) {
                        StartupDto dto = jsonObject.getObject("data", StartupDto.class);

                    HashMap<String, Object> requestParam = new HashMap<>();
                    String response = null;
                    try {
                        requestParam.put("barcode", stationProtocol.getBarcode());
                        requestParam.put("sourceStaNo", stationProtocol.getStationId());
                        requestParam.put("locType1", stationProtocol.getPalletHeight());
                        requestParam.put("row", Utils.getInTaskEnableRow());
                        CreateInTaskParam taskParam = new CreateInTaskParam();
                        taskParam.setTaskNo(dto.getTaskNo());
                        taskParam.setLocNo(dto.getLocNo());
                        taskParam.setTaskPri(dto.getTaskPri());
                        taskParam.setBarcode(stationProtocol.getBarcode());
                        WrkMast wrkMast = commonService.createInTask(taskParam);

                        response = new HttpHandler.Builder()
                                .setUri(wmsUrl)
                                .setPath(wmsSystemInUrl)
                                .setJson(JSON.toJSONString(requestParam))
                                .build()
                                .doPost();
                        JSONObject jsonObject = JSON.parseObject(response);
                        if (jsonObject.getInteger("code").equals(200)) {
                            StartupDto dto = jsonObject.getObject("data", StartupDto.class);

                            CreateInTaskParam taskParam = new CreateInTaskParam();
                            taskParam.setTaskNo(String.valueOf(dto.getTaskNo()));
                            taskParam.setLocNo(dto.getLocNo());
                            taskParam.setTaskPri(dto.getTaskPri());
                            taskParam.setBarcode(stationProtocol.getBarcode());
                            boolean result = commonService.createInTask(taskParam);

                            News.info("请求WMS接口成功！！！url：{}；request：{}；response：{}", wmsUrl + wmsSystemInUrl, JSON.toJSONString(requestParam), response);
                        } else {
                            News.error("请求WMS接口失败！！！url：{}；request：{}；response：{}", wmsUrl + wmsSystemInUrl, JSON.toJSONString(requestParam), response);
                        StationCommand command = stationThread.getMoveCommand(wrkMast.getWrkNo(), stationId, stationId, 0);
                        if(command == null){
                            News.taskInfo(wrkMast.getWrkNo(), "获取输送线命令失败");
                            continue;
                        }
                    } catch (Exception e) {
                        News.error("请求WMS接口异常！！！url：{}；request：{}；response：{}", wmsUrl + wmsSystemInUrl, JSON.toJSONString(requestParam), response, e);
                    } finally {
                        HttpRequestLog httpRequestLog = new HttpRequestLog();
                        httpRequestLog.setName(wmsUrl + wmsSystemInUrl);
                        httpRequestLog.setRequest(JSON.toJSONString(requestParam));
                        httpRequestLog.setResponse(response);
                        httpRequestLog.setCreateTime(new Date());
                        httpRequestLogService.insert(httpRequestLog);
                        MessageQueue.offer(SlaveType.Devp, basDevp.getDevpNo(), new Task(2, command));
                    }
                }
            }
@@ -460,7 +526,7 @@

                    MessageQueue.offer(SlaveType.Devp, stationObjModel.getDeviceNo(), new Task(2, command));
                    redisUtil.set(RedisKeyType.CHECK_OUT_STATION_STAY_TIME_OUT_LIMIT.key + stationObjModel.getStationId(), "lock",10);
                    News.info("输送站点重置命令下发成功，站点号={}，命令数据={}", stationObjModel.getStationId(), JSON.toJSONString(command));
                    News.info("输送站点出库重置命令下发成功，站点号={}，命令数据={}", stationObjModel.getStationId(), JSON.toJSONString(command));
                }
            }
        }
@@ -503,7 +569,7 @@
                    if (wrkMast == null) {
                        MessageQueue.offer(SlaveType.Devp, stationObjModel.getDeviceNo(), new Task(2, command));
                        redisUtil.set(RedisKeyType.CHECK_IN_STATION_STAY_TIME_OUT_LIMIT.key + stationObjModel.getStationId(), "lock",10);
                        News.info("输送站点重置命令下发成功，站点号={}，命令数据={}", stationObjModel.getStationId(), JSON.toJSONString(command));
                        News.info("输送站点重置命令下发成功(task_over)，站点号={}，命令数据={}", stationObjModel.getStationId(), JSON.toJSONString(command));
                    }else {
                        if (wrkMast.getWrkSts() != WrkStsType.NEW_INBOUND.sts && wrkMast.getWrkSts() != WrkStsType.INBOUND_DEVICE_RUN.sts) {
                            Integer crnNo = wrkMast.getCrnNo();
@@ -512,13 +578,13 @@
                                continue;
                            }
                            CrnProtocol crnProtocol = crnThread.getStatus();
                            if (crnProtocol.getStatusType().equals(CrnStatusType.FETCH_MOVING) || crnProtocol.getStatusType().equals(CrnStatusType.FETCHING)) {
                            if (!crnProtocol.getStatusType().equals(CrnStatusType.PUT_MOVING) && !crnProtocol.getStatusType().equals(CrnStatusType.PUTTING)) {
                                continue;
                            }

                            MessageQueue.offer(SlaveType.Devp, stationObjModel.getDeviceNo(), new Task(2, command));
                            redisUtil.set(RedisKeyType.CHECK_IN_STATION_STAY_TIME_OUT_LIMIT.key + stationObjModel.getStationId(), "lock",10);
                            News.info("输送站点重置命令下发成功，站点号={}，命令数据={}", stationObjModel.getStationId(), JSON.toJSONString(command));
                            News.info("输送站点重置命令下发成功(crn_fetch)，站点号={}，命令数据={}", stationObjModel.getStationId(), JSON.toJSONString(command));
                        }
                    }
                }