Merge branch 'stationChange'

Junjie

23 小时以前 ef776e9fd5e4f64e4ad09a3faa12fb7bb646c79c

 src/main/java/com/zy/core/thread/impl/ZyStationV5Thread.java

@@ -2,42 +2,38 @@

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.core.common.Cools;
import com.core.common.DateUtils;
import com.core.common.SpringUtils;
import com.zy.asrs.entity.BasDevp;
import com.zy.asrs.entity.BasStationOpt;
import com.zy.asrs.entity.DeviceConfig;
import com.zy.asrs.entity.DeviceDataLog;
import com.zy.asrs.service.BasDevpService;
import com.zy.asrs.service.BasStationOptService;
import com.zy.asrs.utils.Utils;
import com.zy.common.model.NavigateNode;
import com.zy.common.utils.NavigateUtils;
import com.zy.common.utils.RedisUtil;
import com.zy.core.cache.MessageQueue;
import com.zy.core.cache.OutputQueue;
import com.zy.core.enums.SlaveType;
import com.zy.core.enums.StationCommandType;
import com.zy.core.model.CommandResponse;
import com.zy.core.model.Task;
import com.zy.core.model.command.StationCommand;
import com.zy.core.model.protocol.StationProtocol;
import com.zy.core.model.protocol.StationTaskBufferItem;
import com.zy.core.network.DeviceConnectPool;
import com.zy.core.network.ZyStationConnectDriver;
import com.zy.core.network.entity.ZyStationStatusEntity;
import com.zy.core.service.StationTaskLoopService;
import com.zy.core.thread.impl.v5.StationV5RunBlockReroutePlanner;
import com.zy.core.thread.impl.v5.StationV5SegmentExecutor;
import com.zy.core.utils.DeviceLogRedisKeyBuilder;
import com.zy.core.thread.impl.v5.StationV5StatusReader;
import com.zy.core.thread.support.RecentStationArrivalTracker;
import lombok.Data;
import lombok.extern.slf4j.Slf4j;

import java.text.MessageFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

@@ -45,35 +41,35 @@
@Slf4j
public class ZyStationV5Thread implements Runnable, com.zy.core.thread.StationThread {

    private List<StationProtocol> statusList = new ArrayList<>();
    private static final int SEGMENT_EXECUTOR_POOL_SIZE = 64;

    private DeviceConfig deviceConfig;
    private RedisUtil redisUtil;
    private ZyStationConnectDriver zyStationConnectDriver;
    private int deviceLogCollectTime = 200;
    private boolean initStatus = false;
    private long deviceDataLogTime = System.currentTimeMillis();
    private ExecutorService executor = Executors.newFixedThreadPool(9999);
    private final ExecutorService executor = Executors.newFixedThreadPool(SEGMENT_EXECUTOR_POOL_SIZE);
    private StationV5SegmentExecutor segmentExecutor;
    private final RecentStationArrivalTracker recentArrivalTracker;
    private final StationV5StatusReader statusReader;
    private final StationV5RunBlockReroutePlanner runBlockReroutePlanner;

    public ZyStationV5Thread(DeviceConfig deviceConfig, RedisUtil redisUtil) {
        this.deviceConfig = deviceConfig;
        this.redisUtil = redisUtil;
        this.recentArrivalTracker = new RecentStationArrivalTracker(redisUtil);
        this.segmentExecutor = new StationV5SegmentExecutor(deviceConfig, redisUtil, this::sendCommand);
        this.statusReader = new StationV5StatusReader(deviceConfig, redisUtil, recentArrivalTracker);
        this.runBlockReroutePlanner = new StationV5RunBlockReroutePlanner(redisUtil);
    }

    @Override
    @SuppressWarnings("InfiniteLoopStatement")
    public void run() {
        this.connect();
        deviceLogCollectTime = Utils.getDeviceLogCollectTime();

        Thread readThread = new Thread(() -> {
            while (true) {
                try {
                    if (initStatus) {
                        deviceLogCollectTime = Utils.getDeviceLogCollectTime();
                    }
                    readStatus();
                    statusReader.readStatus(zyStationConnectDriver);
                    Thread.sleep(100);
                } catch (Exception e) {
                    log.error("StationV5Thread Fail", e);
@@ -85,15 +81,7 @@
        Thread processThread = new Thread(() -> {
            while (true) {
                try {
                    int step = 1;
                    Task task = MessageQueue.poll(SlaveType.Devp, deviceConfig.getDeviceNo());
                    if (task != null) {
                        step = task.getStep();
                    }
                    if (step == 2) {
                        StationCommand cmd = (StationCommand) task.getData();
                        executor.submit(() -> segmentExecutor.execute(cmd));
                    }
                    pollAndDispatchQueuedCommand();
                    Thread.sleep(100);
                } catch (Exception e) {
                    log.error("StationV5Process Fail", e);
@@ -101,82 +89,6 @@
            }
        }, "DevpProcess-" + deviceConfig.getDeviceNo());
        processThread.start();
    }

    private void readStatus() {
        if (zyStationConnectDriver == null) {
            return;
        }

        if (statusList.isEmpty()) {
            BasDevpService basDevpService = null;
            try {
                basDevpService = SpringUtils.getBean(BasDevpService.class);
            } catch (Exception ignore) {
            }
            if (basDevpService == null) {
                return;
            }

            BasDevp basDevp = basDevpService
                    .getOne(new QueryWrapper<BasDevp>().eq("devp_no", deviceConfig.getDeviceNo()));
            if (basDevp == null) {
                return;
            }

            List<ZyStationStatusEntity> list = JSONObject.parseArray(basDevp.getStationList(), ZyStationStatusEntity.class);
            for (ZyStationStatusEntity entity : list) {
                StationProtocol stationProtocol = new StationProtocol();
                stationProtocol.setStationId(entity.getStationId());
                statusList.add(stationProtocol);
            }
            initStatus = true;
        }

        List<ZyStationStatusEntity> zyStationStatusEntities = zyStationConnectDriver.getStatus();
        for (ZyStationStatusEntity statusEntity : zyStationStatusEntities) {
            for (StationProtocol stationProtocol : statusList) {
                if (stationProtocol.getStationId().equals(statusEntity.getStationId())) {
                    stationProtocol.setTaskNo(statusEntity.getTaskNo());
                    stationProtocol.setTargetStaNo(statusEntity.getTargetStaNo());
                    stationProtocol.setAutoing(statusEntity.isAutoing());
                    stationProtocol.setLoading(statusEntity.isLoading());
                    stationProtocol.setInEnable(statusEntity.isInEnable());
                    stationProtocol.setOutEnable(statusEntity.isOutEnable());
                    stationProtocol.setEmptyMk(statusEntity.isEmptyMk());
                    stationProtocol.setFullPlt(statusEntity.isFullPlt());
                    stationProtocol.setPalletHeight(statusEntity.getPalletHeight());
                    stationProtocol.setError(statusEntity.getError());
                    stationProtocol.setErrorMsg(statusEntity.getErrorMsg());
                    stationProtocol.setBarcode(statusEntity.getBarcode());
                    stationProtocol.setRunBlock(statusEntity.isRunBlock());
                    stationProtocol.setEnableIn(statusEntity.isEnableIn());
                    stationProtocol.setWeight(statusEntity.getWeight());
                    stationProtocol.setTaskWriteIdx(statusEntity.getTaskWriteIdx());
                }

                if (!Cools.isEmpty(stationProtocol.getSystemWarning())) {
                    if (stationProtocol.isAutoing() && !stationProtocol.isLoading()) {
                        stationProtocol.setSystemWarning("");
                    }
                }
            }
        }

        OutputQueue.DEVP.offer(MessageFormat.format("【{0}】[id:{1}] <<<<< 实时数据更新成功",
                DateUtils.convert(new Date()), deviceConfig.getDeviceNo()));

        if (System.currentTimeMillis() - deviceDataLogTime > deviceLogCollectTime) {
            DeviceDataLog deviceDataLog = new DeviceDataLog();
            deviceDataLog.setOriginData(JSON.toJSONString(zyStationStatusEntities));
            deviceDataLog.setWcsData(JSON.toJSONString(statusList));
            deviceDataLog.setType(String.valueOf(SlaveType.Devp));
            deviceDataLog.setDeviceNo(deviceConfig.getDeviceNo());
            deviceDataLog.setCreateTime(new Date());

            redisUtil.set(DeviceLogRedisKeyBuilder.build(deviceDataLog), deviceDataLog, 60 * 60 * 24);
            deviceDataLogTime = System.currentTimeMillis();
        }
    }

    @Override
@@ -202,16 +114,36 @@

    @Override
    public List<StationProtocol> getStatus() {
        return statusList;
        return statusReader.getStatusList();
    }

    @Override
    public Map<Integer, StationProtocol> getStatusMap() {
        Map<Integer, StationProtocol> map = new HashMap<>();
        for (StationProtocol stationProtocol : statusList) {
        for (StationProtocol stationProtocol : statusReader.getStatusList()) {
            map.put(stationProtocol.getStationId(), stationProtocol);
        }
        return map;
    }

    private void pollAndDispatchQueuedCommand() {
        Task task = MessageQueue.poll(SlaveType.Devp, deviceConfig.getDeviceNo());
        if (task == null || task.getStep() == null || task.getStep() != 2) {
            return;
        }
        submitSegmentCommand((StationCommand) task.getData());
    }

    private void submitSegmentCommand(StationCommand command) {
        if (command == null || executor == null || segmentExecutor == null) {
            return;
        }
        executor.submit(() -> segmentExecutor.execute(command));
    }

    @Override
    public boolean hasRecentArrival(Integer stationId, Integer taskNo) {
        return recentArrivalTracker.hasRecentArrival(stationId, taskNo);
    }

    @Override
@@ -220,6 +152,16 @@
                                     Integer stationId,
                                     Integer targetStationId,
                                     Integer palletSize) {
        return getCommand(commandType, taskNo, stationId, targetStationId, palletSize, null);
    }

    @Override
    public StationCommand getCommand(StationCommandType commandType,
                                     Integer taskNo,
                                     Integer stationId,
                                     Integer targetStationId,
                                     Integer palletSize,
                                     Double pathLenFactor) {
        StationCommand stationCommand = new StationCommand();
        stationCommand.setTaskNo(taskNo);
        stationCommand.setStationId(stationId);
@@ -228,32 +170,125 @@
        stationCommand.setCommandType(commandType);

        if (commandType == StationCommandType.MOVE && !stationId.equals(targetStationId)) {
            List<NavigateNode> nodes = calcPathNavigateNodes(taskNo, stationId, targetStationId);
            List<Integer> path = new ArrayList<>();
            List<Integer> liftTransferPath = new ArrayList<>();
            for (NavigateNode n : nodes) {
                JSONObject v = JSONObject.parseObject(n.getNodeValue());
                if (v == null) {
                    continue;
                }
                Integer stationNo = v.getInteger("stationId");
                if (stationNo == null) {
                    continue;
                }
                path.add(stationNo);
                if (Boolean.TRUE.equals(n.getIsLiftTransferPoint())) {
                    liftTransferPath.add(stationNo);
                }
            }
            if (path.isEmpty()) {
                log.warn("输送线命令生成失败，路径为空，taskNo={}, stationId={}, targetStationId={}",
                        taskNo, stationId, targetStationId);
                return null;
            }
            stationCommand.setNavigatePath(path);
            stationCommand.setLiftTransferPath(liftTransferPath);
            List<NavigateNode> nodes = calcPathNavigateNodes(taskNo, stationId, targetStationId, pathLenFactor);
            return fillMoveCommandPath(stationCommand, nodes, taskNo, stationId, targetStationId);
        }
        return stationCommand;
    }

    @Override
    public synchronized StationCommand getRunBlockRerouteCommand(Integer taskNo,
                                                                 Integer stationId,
                                                                 Integer targetStationId,
                                                                 Integer palletSize) {
        return getRunBlockRerouteCommand(taskNo, stationId, targetStationId, palletSize, null);
    }

    @Override
    public synchronized StationCommand getRunBlockRerouteCommand(Integer taskNo,
                                                                 Integer stationId,
                                                                 Integer targetStationId,
                                                                 Integer palletSize,
                                                                 Double pathLenFactor) {
        if (taskNo == null || taskNo <= 0 || stationId == null || targetStationId == null) {
            return null;
        }
        if (Objects.equals(stationId, targetStationId)) {
            return getCommand(StationCommandType.MOVE, taskNo, stationId, targetStationId, palletSize, pathLenFactor);
        }

        StationTaskLoopService taskLoopService = loadStationTaskLoopService();
        StationTaskLoopService.LoopEvaluation loopEvaluation = taskLoopService == null
                ? new StationTaskLoopService.LoopEvaluation(taskNo, stationId, StationTaskLoopService.LoopIdentitySnapshot.empty(), 0, 0, false)
                : taskLoopService.evaluateLoop(taskNo, stationId, true);
        log.info("输送线堵塞重规划环线识别，taskNo={}, stationId={}, scopeType={}, localStationCount={}, sourceLoopStationCount={}",
                taskNo,
                stationId,
                loopEvaluation.getLoopIdentity().getScopeType(),
                loopEvaluation.getLoopIdentity().getLocalStationCount(),
                loopEvaluation.getLoopIdentity().getSourceLoopStationCount());
        List<List<NavigateNode>> candidatePathList = calcCandidatePathNavigateNodes(taskNo, stationId, targetStationId, pathLenFactor);
        List<StationCommand> candidateCommandList = new ArrayList<>();
        for (List<NavigateNode> candidatePath : candidatePathList) {
            StationCommand rerouteCommand = buildMoveCommand(taskNo, stationId, targetStationId, palletSize, candidatePath);
            if (rerouteCommand == null || rerouteCommand.getNavigatePath() == null || rerouteCommand.getNavigatePath().isEmpty()) {
                continue;
            }
            candidateCommandList.add(rerouteCommand);
        }

        StationV5RunBlockReroutePlanner.PlanResult planResult = runBlockReroutePlanner.plan(
                taskNo,
                stationId,
                loopEvaluation,
                candidateCommandList
        );
        if (candidateCommandList.isEmpty()) {
            log.warn("输送线堵塞重规划失败，候选路径为空，taskNo={}, planCount={}, stationId={}, targetStationId={}",
                    taskNo, planResult.getPlanCount(), stationId, targetStationId);
            return null;
        }

        StationCommand rerouteCommand = planResult.getCommand();
        if (rerouteCommand != null) {
            if (taskLoopService != null) {
                taskLoopService.recordLoopIssue(loopEvaluation, "RUN_BLOCK_REROUTE");
            }
            log.info("输送线堵塞重规划选中候选路线，taskNo={}, planCount={}, stationId={}, targetStationId={}, route={}",
                    taskNo, planResult.getPlanCount(), stationId, targetStationId, JSON.toJSONString(rerouteCommand.getNavigatePath()));
            return rerouteCommand;
        }

        log.warn("输送线堵塞重规划未找到可下发路线，taskNo={}, planCount={}, stationId={}, targetStationId={}, triedRoutes={}",
                taskNo,
                planResult.getPlanCount(),
                stationId,
                targetStationId,
                JSON.toJSONString(planResult.getIssuedRoutePathList()));
        return null;
    }

    @Override
    public synchronized boolean clearPath(Integer taskNo) {
        if (taskNo == null || taskNo <= 0) {
            return false;
        }
        if (zyStationConnectDriver == null) {
            return false;
        }
        List<StationProtocol> status = getStatus();
        if (status == null || status.isEmpty()) {
            return false;
        }

        boolean found = false;
        boolean success = true;
        for (StationProtocol stationProtocol : status) {
            List<StationTaskBufferItem> taskBufferItems = stationProtocol == null ? null : stationProtocol.getTaskBufferItems();
            if (taskBufferItems == null || taskBufferItems.isEmpty()) {
                continue;
            }
            Integer stationId = stationProtocol.getStationId();
            for (StationTaskBufferItem item : taskBufferItems) {
                if (item == null || !Objects.equals(taskNo, item.getTaskNo())) {
                    continue;
                }
                found = true;
                if (!zyStationConnectDriver.clearTaskBufferSlot(stationId, item.getSlotIdx())) {
                    success = false;
                    log.warn("输送站缓存区残留路径清理失败。stationId={}, slotIdx={}, taskNo={}",
                            stationId, item.getSlotIdx(), item.getTaskNo());
                    continue;
                }else {
                    item.setTaskNo(0);
                    item.setTargetStaNo(0);
                    success = true;
                    log.warn("输送站缓存区残留路径清理成功。stationId={}, slotIdx={}, taskNo={}",
                            stationId, item.getSlotIdx(), item.getTaskNo());
                }
            }
        }
        return found && success;
    }

    @Override
@@ -265,6 +300,9 @@
            e.printStackTrace();
        } finally {
            BasStationOptService optService = SpringUtils.getBean(BasStationOptService.class);
            if (optService == null) {
                return commandResponse;
            }
            List<ZyStationStatusEntity> statusListEntity = zyStationConnectDriver.getStatus();
            ZyStationStatusEntity matched = null;
            if (statusListEntity != null) {
@@ -287,12 +325,10 @@
                    null,
                    JSON.toJSONString(command),
                    JSON.toJSONString(matched),
                    1,
                    commandResponse != null && Boolean.TRUE.equals(commandResponse.getResult()) ? 1 : 0,
                    JSON.toJSONString(commandResponse)
            );
            if (optService != null) {
                optService.save(basStationOpt);
            }
            optService.save(basStationOpt);
        }
        return commandResponse;
    }
@@ -307,11 +343,84 @@
        return zyStationConnectDriver.readOriginCommand(address, length);
    }

    private List<NavigateNode> calcPathNavigateNodes(Integer taskNo, Integer startStationId, Integer targetStationId) {
    private List<NavigateNode> calcPathNavigateNodes(Integer taskNo,
                                                     Integer startStationId,
                                                     Integer targetStationId,
                                                     Double pathLenFactor) {
        NavigateUtils navigateUtils = SpringUtils.getBean(NavigateUtils.class);
        if (navigateUtils == null) {
            return new ArrayList<>();
        }
        return navigateUtils.calcByStationId(startStationId, targetStationId, taskNo);
        return navigateUtils.calcByStationId(startStationId, targetStationId, taskNo, pathLenFactor);
    }

    private List<List<NavigateNode>> calcCandidatePathNavigateNodes(Integer taskNo,
                                                                    Integer startStationId,
                                                                    Integer targetStationId,
                                                                    Double pathLenFactor) {
        NavigateUtils navigateUtils = SpringUtils.getBean(NavigateUtils.class);
        if (navigateUtils == null) {
            return new ArrayList<>();
        }
        return navigateUtils.calcCandidatePathByStationId(startStationId, targetStationId, taskNo, pathLenFactor);
    }

    private StationCommand buildMoveCommand(Integer taskNo,
                                            Integer stationId,
                                            Integer targetStationId,
                                            Integer palletSize,
                                            List<NavigateNode> nodes) {
        StationCommand stationCommand = new StationCommand();
        stationCommand.setTaskNo(taskNo);
        stationCommand.setStationId(stationId);
        stationCommand.setTargetStaNo(targetStationId);
        stationCommand.setPalletSize(palletSize);
        stationCommand.setCommandType(StationCommandType.MOVE);
        return fillMoveCommandPath(stationCommand, nodes, taskNo, stationId, targetStationId);
    }

    private StationCommand fillMoveCommandPath(StationCommand stationCommand,
                                               List<NavigateNode> nodes,
                                               Integer taskNo,
                                               Integer stationId,
                                               Integer targetStationId) {
        List<Integer> path = new ArrayList<>();
        List<Integer> liftTransferPath = new ArrayList<>();
        for (NavigateNode node : nodes) {
            JSONObject valueObject;
            try {
                valueObject = JSONObject.parseObject(node.getNodeValue());
            } catch (Exception ignore) {
                continue;
            }
            if (valueObject == null) {
                continue;
            }
            Integer stationNo = valueObject.getInteger("stationId");
            if (stationNo == null) {
                continue;
            }
            path.add(stationNo);
            if (Boolean.TRUE.equals(node.getIsLiftTransferPoint())) {
                liftTransferPath.add(stationNo);
            }
        }
        if (path.isEmpty()) {
            log.warn("输送线命令生成失败，路径为空，taskNo={}, stationId={}, targetStationId={}",
                    taskNo, stationId, targetStationId);
            return null;
        }
        stationCommand.setNavigatePath(path);
        stationCommand.setLiftTransferPath(liftTransferPath);
        stationCommand.setTargetStaNo(path.get(path.size() - 1));
        return stationCommand;
    }

    private StationTaskLoopService loadStationTaskLoopService() {
        try {
            return SpringUtils.getBean(StationTaskLoopService.class);
        } catch (Exception ignore) {
            return null;
        }
    }
}