#入库异常

Junjie

2026-04-11 37efb9725fcbcf921534d032ad2aa4ce2aaa7fde

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

@@ -3,9 +3,11 @@
import com.alibaba.fastjson.JSON;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.core.common.Cools;
import com.zy.asrs.entity.WrkLastno;
import com.zy.asrs.utils.Utils;
import com.zy.asrs.entity.BasDevp;
import com.zy.asrs.service.BasDevpService;
import com.zy.asrs.service.WrkLastnoService;
import com.zy.common.service.CommonService;
import com.zy.common.utils.RedisUtil;
import com.zy.core.News;
@@ -50,6 +52,8 @@
    @Autowired
    private RedisUtil redisUtil;
    @Autowired
    private WrkLastnoService wrkLastnoService;
    @Autowired
    private StoreInTaskGenerationService storeInTaskGenerationService;
    @Autowired
    private StationCommandDispatcher stationCommandDispatcher;
@@ -77,12 +81,12 @@
        stationOperateProcessUtils.submitCheckTaskToCompleteTasks(DISPATCH_INTERVAL_MS);
        // 检测并处理出库排序
        stationOperateProcessUtils.submitCheckStationOutOrderTasks(MAINTENANCE_INTERVAL_MS);
        // 监控输送线绕圈站点
        stationOperateProcessUtils.submitWatchCircleStationTasks(MAINTENANCE_INTERVAL_MS);
//        // 监控输送线绕圈站点
//        stationOperateProcessUtils.submitWatchCircleStationTasks(MAINTENANCE_INTERVAL_MS);
        // 检测输送线运行堵塞
        stationOperateProcessUtils.submitCheckStationRunBlockTasks(MAINTENANCE_INTERVAL_MS);
        // 检测站台空闲超时后的恢复处理
        stationOperateProcessUtils.submitCheckStationIdleRecoverTasks(MAINTENANCE_INTERVAL_MS);
//        // 检测站台空闲超时后的恢复处理
//        stationOperateProcessUtils.submitCheckStationIdleRecoverTasks(MAINTENANCE_INTERVAL_MS);
    }

    @Override
@@ -126,7 +130,29 @@
                        && stationProtocol.getTaskNo() == 0
                        && stationProtocol.isEnableIn()
                ) {
                    StationCommand command = stationThread.getCommand(StationCommandType.MOVE, commonService.getWorkNo(WrkIoType.ENABLE_IN.id), stationId, entity.getBarcodeStation().getStationId(), 0);
                    if (stationProtocol.getIoMode() != 1) {
                        continue;//不属于入库模式
                    }

                    //启动入库，删除条码站退回限制
                    Integer backStationId = entity.getBarcodeStation().getStationId();
                    String lockKey = RedisKeyType.GENERATE_STATION_BACK_LIMIT.key + backStationId;
                    if (redisUtil.hasKey(lockKey)) {
                        StationProtocol backStationProtocol = stationMap.get(backStationId);
                        if (backStationProtocol == null) {
                            continue;
                        }

                        if (backStationProtocol.isAutoing()
                                && !backStationProtocol.isLoading()
                                && stationProtocol.getTaskNo() == 0
                        ) {
                            //条码站自动、无物、工作号0。删除条码站退回限制
                            redisUtil.del(lockKey);
                        }
                    }

                    StationCommand command = stationThread.getCommand(StationCommandType.MOVE, commonService.getWorkNo(WrkIoType.ENABLE_IN.id), stationId, backStationId, 0);
                    stationCommandDispatcher.dispatch(basDevp.getDevpNo(), command, "gsl-process", "enable-in");
                    if (entity.getBarcodeStation() != null && entity.getBarcodeStation().getStationId() != null) {
                        Utils.precomputeInTaskEnableRow(entity.getBarcodeStation().getStationId());
@@ -163,39 +189,108 @@
                if (!handleErrorStationBack(basDevp, stationThread, stationObjModel, stationMap.get(stationId))) {
                    continue;
                }
                if (!canRequestStoreIn(stationMap.get(stationId))) {

                StationProtocol stationProtocol = stationMap.get(stationId);
                if (stationProtocol == null) {
                    continue;
                }

                if (!stationProtocol.isAutoing()) {
                    continue;
                }

                if (!stationProtocol.isLoading()) {
                    continue;
                }

                if (!stationProtocol.isInEnable()) {
                    continue;
                }

                if (stationProtocol.getTaskNo() == 0) {
                    continue;
                }

                if (Cools.isEmpty(stationProtocol.getBarcode())) {
                    continue;
                }

                if (stationProtocol.getError() > 0) {
                    continue;
                }

                if (stationProtocol.isInBarcodeError()) {
                    continue;
                }

                storeInTaskGenerationService.submitGenerateStoreTask(this, basDevp, stationObjModel, DISPATCH_INTERVAL_MS,
                        () -> storeInTaskGenerationService.generate(this, basDevp, stationObjModel));
            }
        }
    }

    private boolean canRequestStoreIn(StationProtocol stationProtocol) {
        return stationProtocol != null
                && stationProtocol.getError() <= 0
                && stationProtocol.isAutoing()
                && stationProtocol.isLoading()
                && stationProtocol.isInEnable()
                && stationProtocol.getTaskNo() > 0
                && !Cools.isEmpty(stationProtocol.getBarcode());
    }

    private boolean handleErrorStationBack(BasDevp basDevp,
                                           StationThread stationThread,
                                           StationObjModel stationObjModel,
                                           StationProtocol stationProtocol) {
        if (stationProtocol.getError() <= 0) {
            return true;
        if (stationProtocol == null) {
            return false;
        }

        Object lock = redisUtil.get(RedisKeyType.GENERATE_STATION_BACK_LIMIT.key + stationProtocol.getStationId());
        if (lock != null) {
        if (!stationProtocol.isAutoing()) {
            return false;
        }

        if (!stationProtocol.isLoading()) {
            return false;
        }

        if (stationProtocol.getError() <= 0) {
            return true;//站点无故障
        }

        if (!stationProtocol.isInBarcodeError()) {
            return true;//站点无异常
        }

        WrkLastno stationBackTaskRange = wrkLastnoService.getById(WrkIoType.STATION_BACK.id);
        Integer currentTaskNo = stationProtocol.getTaskNo();
        if (currentTaskNo != null
                && currentTaskNo > 0
                && stationBackTaskRange != null
                && stationBackTaskRange.getsNo() != null
                && stationBackTaskRange.geteNo() != null
                && currentTaskNo >= stationBackTaskRange.getsNo()
                && currentTaskNo <= stationBackTaskRange.geteNo()) {
            News.info("条码站已处于退回工作号范围，跳过重复生成退回命令。stationId={}，taskNo={}，range=[{}, {}]",
                    stationProtocol.getStationId(),
                    currentTaskNo,
                    stationBackTaskRange.getsNo(),
                    stationBackTaskRange.geteNo());
            return false;
        }

        StationObjModel backStation = stationObjModel.getBackStation();
        if (backStation == null || backStation.getStationId() == null) {
            News.warn("条码站退回失败，退回站未配置。deviceNo={}，stationId={}",
                    basDevp == null ? null : basDevp.getDevpNo(),
                    stationProtocol.getStationId());
            return false;
        }

        // 当前站点已经挂着退回目标时，不再重复生成新的退回工作号。
        if (stationProtocol.getTaskNo() != null
                && stationProtocol.getTaskNo() > 0
                && backStation.getStationId().equals(stationProtocol.getTargetStaNo())) {
            return false;
        }

        String lockKey = RedisKeyType.GENERATE_STATION_BACK_LIMIT.key + stationProtocol.getStationId();
        Object lock = redisUtil.get(lockKey);
        if (lock != null) {
            return false;
        }

        StationCommand command = stationThread.getCommand(StationCommandType.MOVE,
                commonService.getWorkNo(WrkIoType.STATION_BACK.id),
                stationObjModel.getStationId(),
@@ -205,9 +300,9 @@
            return false;
        }
        stationCommandDispatcher.dispatch(basDevp.getDevpNo(), command, "gsl-process", "station-back");
        News.taskInfo(stationProtocol.getTaskNo(), "{}扫码异常，已退回至{}", backStation.getStationId());
        redisUtil.set(RedisKeyType.GENERATE_STATION_BACK_LIMIT.key + stationProtocol.getStationId(), "lock", 10);
        return true;
        News.info("{}扫码站异常，已退回至{},条码站状态：{}", stationProtocol.getTaskNo(), backStation.getStationId(), JSON.toJSONString(stationProtocol));
        redisUtil.set(lockKey, "lock", 60 * 60);
        return false;
    }

}