#

qlsxk

2025-10-16 3979820ffea1120bc553accbdeba6445da91f277

 src/main/java/com/zy/asrs/service/impl/MainServiceImpl.java

@@ -15,6 +15,7 @@
import com.zy.core.action.LiftAction;
import com.zy.core.action.ShuttleAction;
import com.zy.core.cache.SlaveConnection;
import com.zy.core.dispatcher.LiftDispatchUtils;
import com.zy.core.dispatcher.ShuttleDispatchUtils;
import com.zy.core.enums.*;
import com.zy.core.model.command.*;
@@ -57,8 +58,6 @@
    @Autowired
    private ConfigService configService;
    @Autowired
    private NavigateMapUtils navigateMapUtils;
    @Autowired
    private NavigateMapData navigateMapData;
    @Autowired
    private NavigateUtils navigateUtils;
@@ -74,6 +73,10 @@
    private BasShuttleChargeService basShuttleChargeService;
    @Autowired
    private DeviceConfigService deviceConfigService;
    @Autowired
    private LiftDispatchUtils liftDispatchUtils;
    @Autowired
    private BasShuttleService basShuttleService;

    /**
     * 初始化实时地图
@@ -98,7 +101,7 @@
                    }

                    //将数据库地图数据存入redis
                    redisUtil.set(RedisKeyType.MAP.key + lev, JSON.toJSONString(basMap));
                    redisUtil.set(RedisKeyType.MAP.key + lev, lists);
                }

            }
@@ -139,7 +142,7 @@
    public synchronized boolean shuttleInExecuteStep1(WrkMast wrkMast) {
        if (wrkMast.getWrkSts() == WrkStsType.INBOUND_LIFT_RUN_COMPLETE.sts) {
            //获取目标站
            ForkLiftStaProtocol liftSta = ForkLiftUtils.getLiftStaByStaNo(wrkMast.getStaNo());
            LiftStaProtocol liftSta = LiftUtils.getLiftStaByStaNo(wrkMast.getStaNo());
            if (liftSta == null) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，缺少站点信息，禁止派发", wrkMast.getWrkNo());
                return false;
@@ -181,10 +184,10 @@
            }

            //检测障碍物车
            boolean checkObstacle = shuttleOperaUtils.checkObstacle(wrkMast.getLocNo(), new ArrayList<Integer>() {{
            int checkObstacle = shuttleOperaUtils.checkObstacle(wrkMast.getLocNo(), new ArrayList<Integer>() {{
                add(shuttleProtocol.getShuttleNo());
            }}, new ArrayList<>());
            if (checkObstacle) {
            if (checkObstacle > 0) {
                News.info("{}任务，避障范围有小车，等待障碍小车调离中", wrkMast.getWrkNo());
                return false;
            }
@@ -193,9 +196,11 @@
            assignCommand.setShuttleNo(shuttleProtocol.getShuttleNo()); // 四向穿梭车编号
            assignCommand.setTaskMode(ShuttleTaskModeType.TRANSPORT.id);//小车移库任务
            assignCommand.setTaskNo(wrkMast.getWrkNo());//任务号
            assignCommand.setSourceLocNo(shuttleProtocol.getCurrentLocNo());//源库位
            assignCommand.setLocNo(wrkMast.getLocNo());//目标库位
            assignCommand.setAuto(true);//自动模式

            //获取小车到输送站点行走命令
            //获取小车到目标库位命令
            List<ShuttleCommand> commands = shuttleOperaUtils.getStartToTargetCommands(liftSta.getLocNo(), wrkMast.getLocNo(), NavigationMapType.getDfxWithDevice(), assignCommand, shuttleThread);
            if (commands == null) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}小车，路径计算失败", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
@@ -268,42 +273,42 @@
            Integer liftNo = wrkMast.getLiftNo();
            if (liftNo == null) {
                //通过输送线站号获取提升机号
                liftNo = ForkLiftUtils.getConveyorBindLiftNo(wrkMast.getStaNo());
                liftNo = LiftUtils.getConveyorBindLiftNo(wrkMast.getStaNo());
                if (liftNo == null) {
                    News.taskInfo(wrkMast.getWrkNo(), "{}任务，未找到匹配的提升机", wrkMast.getWrkNo());
                    return false;
                }
            }

            ForkLiftThread forkLiftThread = (ForkLiftThread) SlaveConnection.get(SlaveType.ForkLift, liftNo);
            if (forkLiftThread == null) {
            LiftThread liftThread = (LiftThread) SlaveConnection.get(SlaveType.Lift, liftNo);
            if (liftThread == null) {
                return false;
            }
            ForkLiftProtocol forkLiftProtocol = forkLiftThread.getStatus();
            if (forkLiftProtocol == null) {
            LiftProtocol liftProtocol = liftThread.getStatus();
            if (liftProtocol == null) {
                return false;
            }

            //判断提升机是否处于出库模式
            if (!forkLiftProtocol.getIOModeType().equals(ForkLiftIoModeType.OUT)) {
            if (!liftProtocol.getIOModeType().equals(LiftIoModeType.OUT)) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，提升机不处于出库模式，禁止出库", wrkMast.getWrkNo());
                return false;
            }

            //获取源站
            ForkLiftStaProtocol liftSta = ForkLiftUtils.getLiftStaByLev(liftNo, Utils.getLev(wrkMast.getSourceLocNo()));
            LiftStaProtocol liftSta = LiftUtils.getLiftStaByLev(liftNo, Utils.getLev(wrkMast.getSourceLocNo()));
            if (liftSta == null) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，缺少站点信息，禁止派发", wrkMast.getWrkNo());
                return false;
            }

            if (liftSta.getHasCar()) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}站点存在小车，禁止派发", wrkMast.getWrkNo(), liftSta.getStaNo());
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}站点存在小车，禁止派发", wrkMast.getWrkNo(), liftSta.getSiteId());
                return false;
            }

            if (liftSta.getHasTray()) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}站点有托盘，禁止派发", wrkMast.getWrkNo(), liftSta.getStaNo());
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}站点有托盘，禁止派发", wrkMast.getWrkNo(), liftSta.getSiteId());
                return false;
            }

@@ -372,10 +377,10 @@
            //判断小车是否到达货物库位
            if (!shuttleProtocol.getCurrentLocNo().equals(wrkMast.getSourceLocNo())) {
                //检测障碍物车
                boolean checkObstacle = shuttleOperaUtils.checkObstacle(wrkMast.getSourceLocNo(), new ArrayList<Integer>() {{
                int checkObstacle = shuttleOperaUtils.checkObstacle(wrkMast.getSourceLocNo(), new ArrayList<Integer>() {{
                    add(shuttleProtocol.getShuttleNo());
                }}, new ArrayList<>());
                if (checkObstacle) {
                if (checkObstacle > 0) {
                    News.info("{}任务，避障范围有小车，等待障碍小车调离中", wrkMast.getWrkNo());
                    return false;
                }
@@ -397,6 +402,8 @@
            assignCommand.setShuttleNo(shuttleProtocol.getShuttleNo()); // 四向穿梭车编号
            assignCommand.setTaskMode(ShuttleTaskModeType.TRANSPORT.id);//小车移库任务
            assignCommand.setTaskNo(wrkMast.getWrkNo());//任务号
            assignCommand.setSourceLocNo(shuttleProtocol.getCurrentLocNo());//源库位
            assignCommand.setLocNo(liftSta.getLocNo());//目标库位
            assignCommand.setAuto(true);//自动模式

            //获取小车到输送站点行走命令
@@ -423,7 +430,7 @@
            assignCommand.setCommands(commands);

            wrkMast.setWrkSts(WrkStsType.OUTBOUND_SHUTTLE_RUN.sts);//小车搬运中  101.生成出库任务 ==> 102.小车搬运中
            wrkMast.setSourceStaNo(liftSta.getStaNo());
            wrkMast.setSourceStaNo(liftSta.getSiteId());
            wrkMast.setModiTime(new Date());
            wrkMast.setSystemMsg("");//清空消息
            if (wrkMastService.updateById(wrkMast)) {
@@ -500,6 +507,12 @@

            //判断小车是否到达货物库位
            if (!shuttleProtocol.getCurrentLocNo().equals(wrkMast.getSourceLocNo())) {
                //任务被避障取消
                Object cancelLock = redisUtil.get(RedisKeyType.TRAFFIC_CONTROL_SHUTTLE_OBSTACLE_CANCEL_TASK_LOCK.key + wrkMast.getShuttleNo());
                if(cancelLock != null) {
                    return false;
                }

                //小车未到达取货位置
                shuttleDispatchUtils.dispatchShuttle(wrkMast.getWrkNo(), wrkMast.getSourceLocNo(), wrkMast.getShuttleNo());//调度小车到货物所在库位进行取货
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，小车未到达取货位置", wrkMast.getWrkNo(), wrkMast.getSourceLocNo());
@@ -514,10 +527,10 @@
            }

            //检测障碍物车
            boolean checkObstacle = shuttleOperaUtils.checkObstacle(wrkMast.getLocNo(), new ArrayList<Integer>() {{
            int checkObstacle = shuttleOperaUtils.checkObstacle(wrkMast.getLocNo(), new ArrayList<Integer>() {{
                add(shuttleProtocol.getShuttleNo());
            }}, new ArrayList<>());
            if (checkObstacle) {
            if (checkObstacle > 0) {
                News.info("{}任务，避障范围有小车，等待障碍小车调离中", wrkMast.getWrkNo());
                return false;
            }
@@ -526,8 +539,9 @@
            assignCommand.setShuttleNo(shuttleProtocol.getShuttleNo()); // 四向穿梭车编号
            assignCommand.setTaskMode(ShuttleTaskModeType.TRANSPORT.id);//小车移库任务
            assignCommand.setTaskNo(wrkMast.getWrkNo());//任务号
            assignCommand.setSourceLocNo(shuttleProtocol.getCurrentLocNo());//源库位
            assignCommand.setLocNo(wrkMast.getLocNo());//目标库位
            assignCommand.setAuto(true);//自动模式
            assignCommand.setLocNo(wrkMast.getLocNo());

            //获取小车到输送站点行走命令
            List<ShuttleCommand> commands = shuttleOperaUtils.getStartToTargetCommands(wrkMast.getSourceLocNo(), wrkMast.getLocNo(), NavigationMapType.getMapTypes(NavigationMapType.DFX), assignCommand, shuttleThread);
@@ -568,9 +582,9 @@
    }

    /**
     * 货叉提升机任务
     * 提升机任务
     */
    public synchronized void forkLiftIoExecute() {
    public synchronized void liftIoExecute() {
        try {
            //搜索是否有待处理的任务
            List<WrkMast> wrkMasts = wrkMastService.selectList(new EntityWrapper<WrkMast>()
@@ -606,19 +620,25 @@

        //1.生成入库任务 ==> 3.提升机搬运中
        if (wrkMast.getWrkSts() == WrkStsType.NEW_INBOUND.sts) {
            //获取源输送站
            LiftStaProtocol sourceLiftSta = LiftUtils.getLiftStaByStaNo(wrkMast.getSourceStaNo());
            if (sourceLiftSta == null) {
                return false;//找不到站点
            }

            if (!sourceLiftSta.getHasTray()) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，源站无托盘", wrkMast.getWrkNo());
                return false;
            }

            //获取目标输送站
            ForkLiftStaProtocol liftSta = ForkLiftUtils.getLiftStaByStaNo(wrkMast.getStaNo());
            LiftStaProtocol liftSta = LiftUtils.getLiftStaByStaNo(wrkMast.getStaNo());
            if (liftSta == null) {
                return false;//找不到站点
            }

            if (liftSta.getHasTray()) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，目标站存在托盘", wrkMast.getWrkNo());
                return false;
            }

            if (liftSta.getHasCar()) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，目标站存在小车", wrkMast.getWrkNo());
                return false;
            }

@@ -629,17 +649,16 @@
                    return false;
                }

                //获取小车待机位
                String standbyLocNo = Utils.getShuttleStandbyLocNo(liftSta.getLocNo());
                if (standbyLocNo == null) {
                    News.taskInfo(wrkMast.getWrkNo(), "{}任务，获取小车待机位失败", wrkMast.getWrkNo());
                String targetLocNo = navigateUtils.calcEndLocation(wrkMast.getLocNo(), liftSta.getLocNo(), NavigationMapType.getMapTypes(NavigationMapType.NORMAL), null, null, 2);
                if (targetLocNo == null) {//出输送线站点计算失败
                    News.taskInfo(wrkMast.getWrkNo(), "{}任务，调度小车去入库层近点计算失败", wrkMast.getWrkNo());
                    return false;
                }

                //调度小车去待机位
                boolean dispatchShuttle = shuttleDispatchUtils.dispatchShuttle(wrkMast.getWrkNo(), standbyLocNo);
                boolean dispatchShuttle = shuttleDispatchUtils.dispatchShuttle(wrkMast.getWrkNo(), targetLocNo);
                if (!dispatchShuttle) {
                    News.taskInfo(wrkMast.getWrkNo(), "{}任务，调度小车失败", wrkMast.getWrkNo());
                    News.taskInfo(wrkMast.getWrkNo(), "{}任务，调度小车去入库层失败", wrkMast.getWrkNo());
                    return false;
                }
                return false;
@@ -691,7 +710,7 @@
            }

            //获取提升机命令
            LiftCommand liftCommand = liftThread.getPickAndPutCommand(wrkMast.getWrkNo(), wrkMast.getSourceStaNo(), liftSta.getLev());
            LiftCommand liftCommand = liftThread.getPickAndPutCommand(wrkMast.getWrkNo(), wrkMast.getSourceStaNo(), liftSta.getSiteId());
            ArrayList<LiftCommand> commands = new ArrayList<>();
            commands.add(liftCommand);

@@ -700,7 +719,7 @@
            assignCommand.setCommands(commands);
            assignCommand.setLiftNo(liftNo);
            assignCommand.setTaskNo(wrkMast.getWrkNo());
            assignCommand.setTaskMode(ForkLiftTaskModeType.PICK_PUT.id);
            assignCommand.setTaskMode(LiftTaskModeType.PICK_PUT.id);

            wrkMast.setWrkSts(WrkStsType.INBOUND_LIFT_RUN.sts);//提升机搬运中  1.生成入库任务 ==> 3.提升机搬运中
            wrkMast.setSystemMsg("");//清空消息
@@ -742,14 +761,21 @@

                if (shuttleProtocol.getCurrentLocNo().equals(liftSta.getLocNo())) {
                    //小车还在输送站点
                    //获取小车待机位
                    String standbyLocNo = Utils.getShuttleStandbyLocNo(liftSta.getLocNo());
                    if (standbyLocNo == null) {
                        News.taskInfo(wrkMast.getWrkNo(), "{}任务，获取小车待机位失败", wrkMast.getWrkNo());
                    //小车出提升机近点距离
                    int shuttleOutLiftLocationDistance = 2;
                    Config shuttleOutLiftLocationDistanceConfig = configService.selectOne(new EntityWrapper<Config>().eq("code", "shuttleOutLiftLocationDistance"));
                    if (shuttleOutLiftLocationDistanceConfig != null) {
                        shuttleOutLiftLocationDistance = Integer.parseInt(shuttleOutLiftLocationDistanceConfig.getValue());
                    }

                    String targetLocNo = navigateUtils.calcFirstLocation(shuttleProtocol.getCurrentLocNo(), wrkMast.getSourceLocNo(), NavigationMapType.getMapTypes(NavigationMapType.NORMAL), null, null, shuttleOutLiftLocationDistance);
                    if (targetLocNo == null) {//出输送线站点计算失败
                        News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}小车，出输送线站点计算失败", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                        return false;
                    }

                    //调度小车去待机位
                    boolean dispatchShuttle = shuttleDispatchUtils.dispatchShuttle(wrkMast.getWrkNo(), standbyLocNo, wrkMast.getShuttleNo());
                    boolean dispatchShuttle = shuttleDispatchUtils.dispatchShuttle(wrkMast.getWrkNo(), targetLocNo, wrkMast.getShuttleNo());
                    if (!dispatchShuttle) {
                        News.taskInfo(wrkMast.getWrkNo(), "{}任务，小车在输送站点调度小车避让失败", wrkMast.getWrkNo());
                        return false;
@@ -764,13 +790,8 @@
                return false;
            }

            if (liftSta.getHasCar()) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}站点存在小车，禁止派发", wrkMast.getWrkNo(), liftSta.getStaNo());
                return false;
            }

            if (!liftSta.getHasTray()) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}站点无托盘，禁止派发", wrkMast.getWrkNo(), liftSta.getStaNo());
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}站点无托盘，禁止派发", wrkMast.getWrkNo(), liftSta.getSiteId());
                return false;
            }

@@ -778,7 +799,7 @@
            if (liftNo == null) {
                //未分配提升机
                Integer staNo = wrkMast.getStaNo();
                liftNo = ForkLiftUtils.getConveyorBindLiftNo(staNo);
                liftNo = LiftUtils.getConveyorBindLiftNo(staNo);
                if(liftNo == null) {
                    News.taskInfo(wrkMast.getWrkNo(), "{}任务，未找到匹配的提升机", wrkMast.getWrkNo());
                    return false;
@@ -819,7 +840,7 @@
            }

            //获取提升机命令
            LiftCommand liftCommand = liftThread.getPickAndPutCommand(wrkMast.getWrkNo(), liftSta.getLev(), wrkMast.getStaNo());
            LiftCommand liftCommand = liftThread.getPickAndPutCommand(wrkMast.getWrkNo(), liftSta.getSiteId(), wrkMast.getStaNo());
            ArrayList<LiftCommand> commands = new ArrayList<>();
            commands.add(liftCommand);

@@ -828,7 +849,7 @@
            assignCommand.setCommands(commands);
            assignCommand.setLiftNo(liftNo);
            assignCommand.setTaskNo(wrkMast.getWrkNo());
            assignCommand.setTaskMode(ForkLiftTaskModeType.PICK_PUT.id);
            assignCommand.setTaskMode(LiftTaskModeType.PICK_PUT.id);

            wrkMast.setWrkSts(WrkStsType.OUTBOUND_LIFT_RUN.sts);//提升机搬运中  103.生成入库任务 ==> 104.提升机搬运中
            wrkMast.setShuttleNo(null);//释放小车
@@ -844,61 +865,67 @@
    }

    /**
     * 货叉提升机任务完成
     * 提升机任务完成
     */
    public synchronized void forkLiftFinished() {
    public synchronized void liftFinished() {
        try {
            List<DeviceConfig> forkliftList = deviceConfigService.selectList(new EntityWrapper<DeviceConfig>()
                    .eq("device_type", String.valueOf(SlaveType.ForkLift)));
            for (DeviceConfig device : forkliftList) {
            List<DeviceConfig> liftList = deviceConfigService.selectList(new EntityWrapper<DeviceConfig>()
                    .eq("device_type", String.valueOf(SlaveType.Lift)));
            for (DeviceConfig device : liftList) {
                //获取提升机信息
                ForkLiftThread forkLiftThread = (ForkLiftThread) SlaveConnection.get(SlaveType.ForkLift, device.getDeviceNo());
                if(forkLiftThread == null) {
                LiftThread liftThread = (LiftThread) SlaveConnection.get(SlaveType.Lift, device.getDeviceNo());
                if(liftThread == null) {
                    continue;
                }
                ForkLiftProtocol forkLiftProtocol = forkLiftThread.getStatus();
                if (forkLiftProtocol == null) {
                LiftProtocol liftProtocol = liftThread.getStatus();
                if (liftProtocol == null) {
                    continue;
                }

                if (!liftThread.isDeviceIdle()) {
                    continue;
                }

                //提升机为等待确认且空闲
                if (forkLiftProtocol.getProtocolStatus() == ForkLiftProtocolStatusType.WAITING.id
                        && forkLiftProtocol.getWrkNo() != 0
                if (liftProtocol.getProtocolStatus() == LiftProtocolStatusType.WAITING.id
                        && liftProtocol.getTaskNo() != 0
                ) {
                    //将任务档标记为完成
                    WrkMast wrkMast = wrkMastService.selectByWorkNo(forkLiftProtocol.getWrkNo());
                    WrkMast wrkMast = wrkMastService.selectByWorkNo(liftProtocol.getTaskNo());
                    if (wrkMast != null) {
                        if (wrkMast.getWrkSts() == WrkStsType.INBOUND_LIFT_RUN.sts) {
                            //3.提升机搬运中 ==> 4.提升机搬运完成
                            wrkMast.setWrkSts(WrkStsType.INBOUND_LIFT_RUN_COMPLETE.sts);
                            wrkMast.setLiftNo(null);//释放提升机
                            forkLiftThread.setSyncTaskNo(0);
                        }else if (wrkMast.getWrkSts() == WrkStsType.MOVE_NEARBY_COMPLETE.sts) {
                            //303.小车移动至近点完成 -- 调度提升机到小车层
                        } else if (wrkMast.getWrkSts() == WrkStsType.OUTBOUND_LIFT_RUN.sts) {
                            //104.提升机搬运中 ==> 109.出库完成
                            //304.提升机搬运中 ==> 109.出库完成
                            wrkMast.setWrkSts(WrkStsType.COMPLETE_OUTBOUND.sts);
                            wrkMast.setLiftNo(null);//释放提升机
                            forkLiftThread.setSyncTaskNo(0);
                            redisUtil.set(RedisKeyType.FORK_LIFT_PUT_COMPLETE.key + forkLiftProtocol.getLiftNo(), wrkMast.getWmsWrkNo(), 60 * 3);
                        } else if (wrkMast.getWrkSts() == WrkStsType.MOVE_LIFT_RUN.sts) {
                            //306.提升机搬运中 ==> 307.提升机搬运完成
                            wrkMast.setWrkSts(WrkStsType.MOVE_LIFT_RUN_COMPLETE.sts);
                            forkLiftThread.setSyncTaskNo(0);
                        } else {
                            News.error("提升机确认失败，提升机号={}，工作号={}", liftProtocol.getLiftNo(), liftProtocol.getTaskNo());
                            return;
                        }

                        wrkMast.setModiTime(new Date());
                        if (wrkMastService.updateById(wrkMast)) {
                            forkLiftThread.reset();
                            News.info("提升机已确认且任务完成状态。提升机号={}", forkLiftProtocol.getLiftNo());
                            liftThread.reset();
                            News.info("提升机已确认且任务完成状态。提升机号={}", liftProtocol.getLiftNo());
                        } else {
                            News.error("提升机已确认且任务完成状态,复位失败，但未找到工作档。提升机号={}，工作号={}", forkLiftProtocol.getLiftNo(), forkLiftProtocol.getWrkNo());
                            News.error("提升机已确认且任务完成状态,复位失败，但未找到工作档。提升机号={}，工作号={}", liftProtocol.getLiftNo(), liftProtocol.getTaskNo());
                        }
                    }else {
                        boolean checkPreviewDispatchForkLift = commonService.checkWorkNoContainMk(forkLiftProtocol.getWrkNo(), WrkIoType.FORKLIFT_MOVE.id);
                        if (checkPreviewDispatchForkLift) {
                        boolean checkPreviewDispatchLift = commonService.checkWorkNoContainMk(liftProtocol.getTaskNo(), WrkIoType.PREVIEW_LIFT_MOVE.id);
                        if (checkPreviewDispatchLift) {
                            //属于提升机预调度移动任务
                            //无工作档支撑，直接确认完成
                            forkLiftThread.setSyncTaskNo(0);
                            forkLiftThread.reset();
                            News.info("已确认提升机预调度移动任务。提升机号={}", forkLiftProtocol.getLiftNo());
                            liftThread.setSyncTaskNo(0);
                            liftThread.reset();
                            News.info("已确认提升机预调度移动任务。提升机号={}", liftProtocol.getLiftNo());
                        }
                    }
                }
@@ -999,31 +1026,31 @@
     */
    private void recLiftErr() {
        Date now = new Date();
        List<DeviceConfig> forkliftList = deviceConfigService.selectList(new EntityWrapper<DeviceConfig>()
                .eq("device_type", String.valueOf(SlaveType.ForkLift)));
        for (DeviceConfig device : forkliftList) {
        List<DeviceConfig> liftList = deviceConfigService.selectList(new EntityWrapper<DeviceConfig>()
                .eq("device_type", String.valueOf(SlaveType.Lift)));
        for (DeviceConfig device : liftList) {
            // 获取提升机信息
            ForkLiftThread forkLiftThread = (ForkLiftThread) SlaveConnection.get(SlaveType.ForkLift, device.getDeviceNo());
            if (forkLiftThread == null) {
            LiftThread liftThread = (LiftThread) SlaveConnection.get(SlaveType.Lift, device.getDeviceNo());
            if (liftThread == null) {
                continue;
            }
            ForkLiftProtocol forkLiftProtocol = forkLiftThread.getStatus();
            if (forkLiftProtocol == null) {
            LiftProtocol liftProtocol = liftThread.getStatus();
            if (liftProtocol == null) {
                continue;
            }

            if (forkLiftProtocol.getTaskNo() != 0) {
            if (liftProtocol.getTaskNo() != 0) {
                //有任务
                BasLiftErrLog latest = basLiftErrLogService.findLatestByTaskNo(device.getDeviceNo(), forkLiftProtocol.getTaskNo());
                BasLiftErrLog latest = basLiftErrLogService.findLatestByTaskNo(device.getDeviceNo(), liftProtocol.getTaskNo());
                // 有异常
                if (latest == null) {
                    if (forkLiftProtocol.getErrorCode() != null && forkLiftProtocol.getErrorCode() != 0) {
                        WrkMast wrkMast = wrkMastService.selectByWorkNo(forkLiftProtocol.getWrkNo());
                    if (liftProtocol.getErrorCode() != null && liftProtocol.getErrorCode() != 0) {
                        WrkMast wrkMast = wrkMastService.selectByWorkNo(liftProtocol.getTaskNo());
                        if (wrkMast == null) {
                            continue;
                        }

                        BasLiftErr basLiftErr = basLiftErrService.queryByCode(forkLiftProtocol.getErrorCode());
                        BasLiftErr basLiftErr = basLiftErrService.queryByCode(liftProtocol.getErrorCode());
                        String errName = basLiftErr==null? "未知异常":basLiftErr.getErrName();

                        BasLiftErrLog basLiftErrLog = new BasLiftErrLog(
@@ -1048,7 +1075,7 @@
                                now,    // 修改时间
                                null,    // 修改人员
                                "任务中异常",    // 备注
                                JSON.toJSONString(forkLiftProtocol)    // 系统状态数据
                                JSON.toJSONString(liftProtocol)    // 系统状态数据
                        );
                        if (!basLiftErrLogService.insert(basLiftErrLog)) {
                            News.error("提升机plc异常记录失败 ===>> [id:{}] [error:{}]", device.getDeviceNo(), errName);
@@ -1056,7 +1083,7 @@
                    }
                } else {
                    // 异常修复
                    if (forkLiftProtocol.getErrorCode() == null || forkLiftProtocol.getErrorCode() == 0) {
                    if (liftProtocol.getErrorCode() == null || liftProtocol.getErrorCode() == 0) {
                        latest.setEndTime(now);
                        latest.setUpdateTime(now);
                        latest.setStatus(2);
@@ -1091,8 +1118,26 @@
                }

                //判断当前小车是否满足需要充电要求
                if (!shuttleThread.isRequireCharge()) {
                    continue;
                if (shuttleThread.isRequireCharge().equals(ShuttleRequireChargeType.NONE)) {
                    continue;//无需充电
                }

                boolean forceCharge = true;
                if (shuttleThread.isRequireCharge().equals(ShuttleRequireChargeType.SUGGEST_CHARGE)) {
                    BasShuttle basShuttle = basShuttleService.selectOne(new EntityWrapper<BasShuttle>().eq("shuttle_no", device.getDeviceNo()));
                    if (basShuttle != null) {
                        Integer suggestChargeLine = basShuttle.getSuggestChargeLine();
                        boolean chargeSuggestResult = Integer.parseInt(shuttleProtocol.getBatteryPower()) < suggestChargeLine;
                        if (chargeSuggestResult) {
                            //检测系统是否有任务
                            List<WrkMast> wrkMasts = wrkMastService.selectList(new EntityWrapper<WrkMast>().in("io_type", 1, 101, 201));
                            if (wrkMasts.isEmpty()) {
                                forceCharge = false;
                            }else {
                                continue;
                            }
                        }
                    }
                }

                WrkMast wrkMast1 = wrkMastService.selectShuttleWorking(shuttleProtocol.getShuttleNo());
@@ -1168,7 +1213,7 @@
                wrkMast.setIoPri((double) 999);
                wrkMast.setLocNo(chargeLocNo);
                wrkMast.setShuttleNo(device.getDeviceNo());
                wrkMast.setMemo("charge");
                wrkMast.setMemo(forceCharge ? "forceCharge" : "suggestCharge");
                wrkMast.setAppeTime(new Date());
                if (!wrkMastService.insert(wrkMast)) {
                    News.error("保存{}号四向穿梭车充电任务失败!!!", device.getDeviceNo());
@@ -1318,7 +1363,7 @@
            List<ShuttleCommand> commands = shuttleOperaUtils.getShuttleChargeCommand(assignCommand, shuttleThread, true);
            assignCommand.setCommands(commands);//运行命令

            wrkMast.setWrkSts(WrkStsType.CHARGE_SHUTTLE_WORKING.sts);
            wrkMast.setWrkSts(WrkStsType.CHARGE_SHUTTLE_START_CHARGING.sts);
            wrkMast.setModiTime(new Date());
            if (!wrkMastService.updateById(wrkMast)) {
                return false;
@@ -1335,7 +1380,7 @@

    //小车停止充电
    private synchronized boolean executeShuttleChargeStepStopCharge(WrkMast wrkMast) {
        if (wrkMast.getWrkSts() == WrkStsType.CHARGE_SHUTTLE_WORKING.sts) {
        if (wrkMast.getWrkSts() == WrkStsType.CHARGE_SHUTTLE_CHARGING.sts) {
            ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, wrkMast.getShuttleNo());
            if (shuttleThread == null) {
                return false;
@@ -1345,7 +1390,21 @@
                return false;
            }

            if (!shuttleThread.isChargingCompleted()) {
            boolean stopCharge = false;
            if (wrkMast.getMemo().equals("suggestChargeTaskStop")) {
                stopCharge = true;
            }else {
                if (shuttleThread.isChargingCompleted()) {
                    stopCharge = true;
                }
            }

            if (!stopCharge) {
                return false;
            }

            Object limitObj = redisUtil.get(RedisKeyType.TASK_RUN_LIMIT.key + wrkMast.getWrkNo());
            if (limitObj != null) {
                return false;
            }

@@ -1361,6 +1420,7 @@

            //下发任务
            shuttleAction.assignWork(shuttleProtocol.getShuttleNo(), assignCommand);
            redisUtil.set(RedisKeyType.TASK_RUN_LIMIT.key + wrkMast.getWrkNo(), "limit", 10);
            return false;
        }
        return true;
@@ -1368,7 +1428,7 @@

    //小车离开充电桩
    private synchronized boolean executeShuttleChargeStepLeaveCharge(WrkMast wrkMast) {
        if (wrkMast.getWrkSts() == WrkStsType.CHARGE_SHUTTLE_COMPLETE.sts) {
        if (wrkMast.getWrkSts() == WrkStsType.CHARGE_SHUTTLE_CHARGING_COMPLETE.sts) {
            ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, wrkMast.getShuttleNo());
            if (shuttleThread == null) {
                return false;
@@ -1384,10 +1444,10 @@
            }

            //检测障碍物车
            boolean checkObstacle = shuttleOperaUtils.checkObstacle(basShuttleCharge.getWaitLocNo(), new ArrayList<Integer>() {{
            int checkObstacle = shuttleOperaUtils.checkObstacle(basShuttleCharge.getWaitLocNo(), new ArrayList<Integer>() {{
                add(shuttleProtocol.getShuttleNo());
            }}, new ArrayList<>());
            if (checkObstacle) {
            if (checkObstacle > 0) {
                News.info("{}任务，避障范围有小车，等待障碍小车调离中", wrkMast.getWrkNo());
                return false;
            }
@@ -1485,36 +1545,20 @@
                return false;
            }

            //获取源输送站
            LiftStaProtocol liftSta = LiftUtils.getLiftStaByStaNo(wrkMast.getSourceStaNo());
            if (liftSta == null) {
                return false;//找不到站点
            }

            if (liftSta.getHasCar()) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，源站存在小车", wrkMast.getWrkNo());
            //搜索最近且无故障提升机
            LiftStaProtocol recentLiftStation = liftDispatchUtils.getRecentLiftStation(shuttleProtocol.getShuttleNo(), Utils.getLev(shuttleProtocol.getCurrentLocNo()));
            if(recentLiftStation == null) {
                News.info("{}号小车，{}目标库位，没有可用空闲输送站点", shuttleProtocol.getShuttleNo(), wrkMast.getLocNo());
                return false;
            }

            //获取目标输送站
            LiftStaProtocol liftStaTarget = LiftUtils.getLiftStaByStaNo(wrkMast.getStaNo());
            if (liftStaTarget == null) {
                return false;//找不到站点
            }

            if (liftStaTarget.getHasCar()) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，目标站存在小车", wrkMast.getWrkNo());
            LiftStaProtocol targetLiftSta = LiftUtils.getLiftStaByLev(recentLiftStation.getLiftNo(), Utils.getLev(wrkMast.getLocNo()));
            if(targetLiftSta == null) {
                return false;
            }

            ShuttleAssignCommand assignCommand = new ShuttleAssignCommand();
            assignCommand.setShuttleNo(shuttleProtocol.getShuttleNo()); // 四向穿梭车编号
            assignCommand.setTaskMode(ShuttleTaskModeType.MOVE_LOC_NO.id);//小车移库任务
            assignCommand.setTaskNo(wrkMast.getWrkNo());//任务号
            assignCommand.setAuto(true);//自动模式

            //计算近点位置
            String endLocation = navigateUtils.calcEndLocation(shuttleProtocol.getCurrentLocNo(), liftSta.getLocNo(), NavigationMapType.getMapTypes(NavigationMapType.NORMAL), null, null, 1);
            String endLocation = navigateUtils.calcEndLocation(shuttleProtocol.getCurrentLocNo(), recentLiftStation.getLocNo(), NavigationMapType.getMapTypes(NavigationMapType.NORMAL), null, null, 1);
            if (endLocation == null) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，小车近点位置计算失败", wrkMast.getWrkNo());
                return false;
@@ -1523,11 +1567,21 @@
            //小车已在近点位置无需前往
            if (shuttleProtocol.getCurrentLocNo().equals(endLocation)) {
                wrkMast.setWrkSts(WrkStsType.MOVE_NEARBY_COMPLETE.sts);//小车移动到提升机中  301.生成小车移库任务 ==> 303.小车移动至近点完成
                wrkMast.setSourceStaNo(recentLiftStation.getSiteId());
                wrkMast.setStaNo(targetLiftSta.getSiteId());
                wrkMast.setModiTime(now);
                wrkMast.setSystemMsg("");//清空消息
                wrkMastService.updateById(wrkMast);
                return true;
            }

            ShuttleAssignCommand assignCommand = new ShuttleAssignCommand();
            assignCommand.setShuttleNo(shuttleProtocol.getShuttleNo()); // 四向穿梭车编号
            assignCommand.setTaskMode(ShuttleTaskModeType.MOVE_LOC_NO.id);//小车移库任务
            assignCommand.setTaskNo(wrkMast.getWrkNo());//任务号
            assignCommand.setSourceLocNo(shuttleProtocol.getCurrentLocNo());//源库位
            assignCommand.setLocNo(endLocation);
            assignCommand.setAuto(true);//自动模式

            //获取小车到近点行走命令
            List<ShuttleCommand> commands = shuttleOperaUtils.getStartToTargetCommands(shuttleProtocol.getCurrentLocNo(), endLocation, NavigationMapType.getMapTypes(NavigationMapType.NORMAL, NavigationMapType.SHUTTLE), assignCommand, shuttleThread);
@@ -1539,6 +1593,8 @@
            assignCommand.setCommands(commands);

            wrkMast.setWrkSts(WrkStsType.MOVE_NEARBY.sts);//小车移动到提升机中  301.生成小车移库任务 ==> 302.小车移动至近点中
            wrkMast.setSourceStaNo(recentLiftStation.getSiteId());
            wrkMast.setStaNo(targetLiftSta.getSiteId());
            wrkMast.setModiTime(now);
            wrkMast.setSystemMsg("");//清空消息
            if (wrkMastService.updateById(wrkMast)) {
@@ -1627,10 +1683,17 @@
                return false;
            }

            int targetLev = Utils.getLev(wrkMast.getLocNo());
            if (liftProtocol.getLev() != targetLev) {
            Object object = redisUtil.get(RedisKeyType.LIFT_MOVE_TO_SHUTTLE_LIMIT.key + wrkMast.getWrkNo());
            int targetLev = Utils.getLev(shuttleProtocol.getCurrentLocNo());
            if (object == null || liftProtocol.getLev() != targetLev) {
                //获取提升机命令
                LiftCommand liftCommand = liftThread.getMoveCommand(wrkMast.getWrkNo(), liftProtocol.getLev(), targetLev);
                LiftStaProtocol startSta = LiftUtils.getLiftStaByLev(liftProtocol.getLiftNo(), liftProtocol.getLev());
                LiftStaProtocol targetSta = LiftUtils.getLiftStaByLev(liftProtocol.getLiftNo(), targetLev);
                if (startSta == null || targetSta == null) {
                    News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}号提升机，站点数据不存在", wrkMast.getWrkNo(), wrkMast.getLiftNo());
                    return false;
                }
                LiftCommand liftCommand = liftThread.getMoveCommand(commonService.getWorkNo(WrkIoType.PREVIEW_LIFT_MOVE.id), startSta.getSiteId(), targetSta.getSiteId());
                ArrayList<LiftCommand> commands = new ArrayList<>();
                commands.add(liftCommand);

@@ -1639,21 +1702,32 @@
                assignCommand.setCommands(commands);
                assignCommand.setLiftNo(wrkMast.getLiftNo());
                assignCommand.setTaskNo(wrkMast.getWrkNo());
                assignCommand.setTaskMode(ForkLiftTaskModeType.MOVE.id);
                assignCommand.setTaskMode(LiftTaskModeType.MOVE.id);
                //下发任务
                liftAction.assignWork(wrkMast.getLiftNo(), assignCommand);
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}号提升机在{}层，提升机不在小车层，调度移动中", wrkMast.getWrkNo(), liftProtocol.getLev(), wrkMast.getLiftNo());
                redisUtil.set(RedisKeyType.LIFT_MOVE_TO_SHUTTLE_LIMIT.key + wrkMast.getWrkNo(), "lift_moving", 60 * 3);
                redisUtil.set(RedisKeyType.TASK_RUN_LIMIT.key + wrkMast.getWrkNo(), "lock", 8);
                return false;
            }

            Object limitObj = redisUtil.get(RedisKeyType.TASK_RUN_LIMIT.key + wrkMast.getWrkNo());
            if (limitObj != null) {
                return false;
            }

            String liftLocNo = liftThread.getCurrentLocNo();

            ShuttleAssignCommand assignCommand = new ShuttleAssignCommand();
            assignCommand.setShuttleNo(shuttleProtocol.getShuttleNo()); // 四向穿梭车编号
            assignCommand.setTaskMode(ShuttleTaskModeType.MOVE_LOC_NO.id);//小车移库任务
            assignCommand.setTaskNo(wrkMast.getWrkNo());//任务号
            assignCommand.setSourceLocNo(shuttleProtocol.getCurrentLocNo());//源库位
            assignCommand.setLocNo(liftLocNo);
            assignCommand.setAuto(true);//自动模式

            //获取小车到提升机行走命令
            List<ShuttleCommand> commands = shuttleOperaUtils.getStartToTargetCommands(shuttleProtocol.getCurrentLocNo(), liftThread.getCurrentLocNo(), NavigationMapType.getNormalWithDevice(), assignCommand, shuttleThread);
            List<ShuttleCommand> commands = shuttleOperaUtils.getStartToTargetCommands(shuttleProtocol.getCurrentLocNo(), liftLocNo, NavigationMapType.getMapTypes(NavigationMapType.NORMAL), assignCommand, shuttleThread, "inLift");
            if (commands == null) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}小车，路径计算失败", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                return false;//路径解锁失败
@@ -1709,13 +1783,13 @@
                return false;//缺少站点信息
            }

            if (liftSta.getHasTray()) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，目标站存在托盘，禁止派发", wrkMast.getWrkNo());
            if (liftSta.getHasCar()) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，目标站存在小车，禁止派发", wrkMast.getWrkNo());
                return false;//有托盘跳过
            }

            //获取提升机命令
            LiftCommand liftCommand = liftThread.getShuttleSwitchCommand(wrkMast.getWrkNo(), sourceLiftSta.getLev(), liftSta.getLev());
            LiftCommand liftCommand = liftThread.getShuttleSwitchCommand(wrkMast.getWrkNo(), sourceLiftSta.getSiteId(), liftSta.getSiteId());
            ArrayList<LiftCommand> commands = new ArrayList<>();
            commands.add(liftCommand);

@@ -1724,7 +1798,7 @@
            assignCommand.setCommands(commands);
            assignCommand.setLiftNo(wrkMast.getLiftNo());
            assignCommand.setTaskNo(wrkMast.getWrkNo());
            assignCommand.setTaskMode(ForkLiftTaskModeType.SHUTTLE_SWITCH.id);
            assignCommand.setTaskMode(LiftTaskModeType.SHUTTLE_SWITCH.id);

            wrkMast.setWrkSts(WrkStsType.MOVE_LIFT_RUN.sts);//提升机搬运中  305.小车迁入提升机完成 ==> 306.提升机搬运中
            wrkMast.setSystemMsg("");//清空消息
@@ -1764,25 +1838,64 @@
                return false;
            }

            if (Utils.getLev(shuttleProtocol.getCurrentLocNo()) != Utils.getLev(wrkMast.getLocNo())) {
                Object object = redisUtil.get(RedisKeyType.SHUTTLE_UPDATE_LOCATION.key + shuttleProtocol.getShuttleNo());
                if(object != null) {
                    return false;
                }

                ShuttleAssignCommand assignCommand = new ShuttleAssignCommand();
                assignCommand.setShuttleNo(shuttleProtocol.getShuttleNo()); // 四向穿梭车编号
                assignCommand.setTaskMode(ShuttleTaskModeType.UPDATE_LOCATION.id);//更新坐标
                assignCommand.setTaskNo(wrkMast.getWrkNo());//任务号
                assignCommand.setAuto(true);//自动模式
                assignCommand.setSourceLocNo(shuttleProtocol.getCurrentLocNo());//源库位
                assignCommand.setLocNo(wrkMast.getLocNo());//目标库位

                //更新小车坐标
                ShuttleCommand command = shuttleThread.getUpdateLocationCommand(wrkMast.getWrkNo(), wrkMast.getLocNo());
                ArrayList<ShuttleCommand> commands = new ArrayList<>();
                commands.add(command);

                assignCommand.setCommands(commands);
                //下发任务
                shuttleAction.assignWork(shuttleProtocol.getShuttleNo(), assignCommand);
                redisUtil.set(RedisKeyType.SHUTTLE_UPDATE_LOCATION.key + shuttleProtocol.getShuttleNo(), "update", 10);
                return false;
            }

            //小车出提升机近点距离
            int shuttleOutLiftLocationDistance = 2;
            Config shuttleOutLiftLocationDistanceConfig = configService.selectOne(new EntityWrapper<Config>().eq("code", "shuttleOutLiftLocationDistance"));
            if (shuttleOutLiftLocationDistanceConfig != null) {
                shuttleOutLiftLocationDistance = Integer.parseInt(shuttleOutLiftLocationDistanceConfig.getValue());
            }

            String targetLocNo = navigateUtils.calcFirstLocation(shuttleProtocol.getCurrentLocNo(), wrkMast.getLocNo(), NavigationMapType.getMapTypes(NavigationMapType.NORMAL), null, null, shuttleOutLiftLocationDistance);
            if (targetLocNo == null) {//出提升机近点计算失败
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}小车，出提升机近点计算失败", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                return false;
            }

            ShuttleAssignCommand assignCommand = new ShuttleAssignCommand();
            assignCommand.setShuttleNo(shuttleProtocol.getShuttleNo()); // 四向穿梭车编号
            assignCommand.setTaskMode(ShuttleTaskModeType.UPDATE_LOCATION.id);//更新坐标
            assignCommand.setTaskMode(ShuttleTaskModeType.MOVE_LOC_NO.id);//小车移库任务
            assignCommand.setTaskNo(wrkMast.getWrkNo());//任务号
            assignCommand.setAuto(true);//自动模式
            assignCommand.setSourceLocNo(shuttleProtocol.getCurrentLocNo());//源库位
            assignCommand.setLocNo(wrkMast.getLocNo());//目标库位
            assignCommand.setLocNo(targetLocNo);//目标库位

            //更新小车坐标
            ShuttleCommand command = shuttleThread.getUpdateLocationCommand(wrkMast.getWrkNo(), wrkMast.getLocNo());
            ArrayList<ShuttleCommand> commands = new ArrayList<>();
            commands.add(command);

            //获取小车到近点命令
            List<ShuttleCommand> commands = shuttleOperaUtils.getStartToTargetCommands(shuttleProtocol.getCurrentLocNo(), targetLocNo, NavigationMapType.getMapTypes(NavigationMapType.NORMAL), assignCommand, shuttleThread);
            if (commands == null) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}小车，路径计算失败", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                return false;//路径计算失败
            }
            assignCommand.setCommands(commands);

            wrkMast.setWrkSts(WrkStsType.MOVE_OUT_LIFT.sts);//小车迁出提升机中
            wrkMast.setSystemMsg("");//清空消息
            wrkMast.setModiTime(now);

            if (wrkMastService.updateById(wrkMast)) {
                //下发任务
                shuttleAction.assignWork(shuttleProtocol.getShuttleNo(), assignCommand);
@@ -1858,74 +1971,74 @@
    }

    //自动切换出入库模式
    public void autoSwitchForkLiftIOMode() {
//        List<DeviceConfig> forkliftList = deviceConfigService.selectList(new EntityWrapper<DeviceConfig>()
//                .eq("device_type", String.valueOf(SlaveType.ForkLift)));
//        for (DeviceConfig device : forkliftList) {
//            Integer liftNo = device.getDeviceNo();
//            ForkLiftThread forkLiftThread = (ForkLiftThread) SlaveConnection.get(SlaveType.ForkLift, liftNo);
//            if (forkLiftThread == null) {
//                continue;
//            }
//            ForkLiftProtocol forkLiftProtocol = forkLiftThread.getStatus();
//            if (forkLiftProtocol == null) {
//                continue;
//            }
//
//            List<Integer> liftAllStaNo = ForkLiftUtils.getLiftAllStaNo(liftNo);
//            if (liftAllStaNo.isEmpty()) {
//                continue;
//            }
//
//            List<Integer> conveyorBindLiftAllStaNo = ForkLiftUtils.getConveyorBindLiftAllStaNo(liftNo);
//            if (conveyorBindLiftAllStaNo.isEmpty()) {
//                continue;
//            }
//
//            //获取入库任务
//            List<WrkMast> inWrkMasts = wrkMastService.selectList(new EntityWrapper<WrkMast>()
//                    .in("sta_no", liftAllStaNo)
//                    .in("wrk_sts"
//                            , WrkStsType.NEW_INBOUND.sts
//                            , WrkStsType.INBOUND_DEVICE_RUN.sts
//                            , WrkStsType.INBOUND_LIFT_RUN.sts
//                            , WrkStsType.INBOUND_LIFT_RUN_COMPLETE.sts
//                            , WrkStsType.INBOUND_SHUTTLE_RUN.sts
//                            , WrkStsType.INBOUND_SHUTTLE_RUN_COMPLETE.sts
//                    ));
//
//            //获取出库任务
//            List<WrkMast> outWrkMasts = wrkMastService.selectList(new EntityWrapper<WrkMast>()
//                    .in("sta_no", conveyorBindLiftAllStaNo)
//                    .in("wrk_sts"
//                            , WrkStsType.NEW_OUTBOUND.sts
//                            , WrkStsType.OUTBOUND_SHUTTLE_RUN.sts
//                            , WrkStsType.OUTBOUND_SHUTTLE_RUN_COMPLETE.sts
//                            , WrkStsType.OUTBOUND_LIFT_RUN.sts
//                            , WrkStsType.OUTBOUND_LIFT_RUN_COMPLETE.sts
//                    ));
//
//            if (forkLiftProtocol.getIOModeType().equals(ForkLiftIoModeType.NONE)) {
//                //未知模式
//                if (!inWrkMasts.isEmpty()) {
//                    forkLiftThread.switchIOMode(ForkLiftIoModeType.IN);
//                } else if (!outWrkMasts.isEmpty()) {
//                    forkLiftThread.switchIOMode(ForkLiftIoModeType.OUT);
//                }else {
//                    forkLiftThread.switchIOMode(ForkLiftIoModeType.IN);
//                }
//            } else if (forkLiftProtocol.getIOModeType().equals(ForkLiftIoModeType.IN)) {
//                //入库模式
//                if (inWrkMasts.isEmpty() && !outWrkMasts.isEmpty()) {
//                    forkLiftThread.switchIOMode(ForkLiftIoModeType.OUT);
//                }
//            } else if (forkLiftProtocol.getIOModeType().equals(ForkLiftIoModeType.OUT)) {
//                //出库模式
//                if (outWrkMasts.isEmpty() && !inWrkMasts.isEmpty()) {
//                    forkLiftThread.switchIOMode(ForkLiftIoModeType.IN);
//                }
//            }
//        }
    public void autoSwitchLiftIOMode() {
        List<DeviceConfig> liftList = deviceConfigService.selectList(new EntityWrapper<DeviceConfig>()
                .eq("device_type", String.valueOf(SlaveType.Lift)));
        for (DeviceConfig device : liftList) {
            Integer liftNo = device.getDeviceNo();
            LiftThread liftThread = (LiftThread) SlaveConnection.get(SlaveType.Lift, liftNo);
            if (liftThread == null) {
                continue;
            }
            LiftProtocol liftProtocol = liftThread.getStatus();
            if (liftProtocol == null) {
                continue;
            }

            List<Integer> liftAllStaNo = LiftUtils.getLiftAllStaNo(liftNo);
            if (liftAllStaNo.isEmpty()) {
                continue;
            }

            List<Integer> conveyorBindLiftAllStaNo = LiftUtils.getConveyorBindLiftAllStaNo(liftNo);
            if (conveyorBindLiftAllStaNo.isEmpty()) {
                continue;
            }

            //获取入库任务
            List<WrkMast> inWrkMasts = wrkMastService.selectList(new EntityWrapper<WrkMast>()
                    .in("sta_no", liftAllStaNo)
                    .in("wrk_sts"
                            , WrkStsType.NEW_INBOUND.sts
                            , WrkStsType.INBOUND_DEVICE_RUN.sts
                            , WrkStsType.INBOUND_LIFT_RUN.sts
                            , WrkStsType.INBOUND_LIFT_RUN_COMPLETE.sts
                            , WrkStsType.INBOUND_SHUTTLE_RUN.sts
                            , WrkStsType.INBOUND_SHUTTLE_RUN_COMPLETE.sts
                    ));

            //获取出库任务
            List<WrkMast> outWrkMasts = wrkMastService.selectList(new EntityWrapper<WrkMast>()
                    .in("sta_no", conveyorBindLiftAllStaNo)
                    .in("wrk_sts"
                            , WrkStsType.NEW_OUTBOUND.sts
                            , WrkStsType.OUTBOUND_SHUTTLE_RUN.sts
                            , WrkStsType.OUTBOUND_SHUTTLE_RUN_COMPLETE.sts
                            , WrkStsType.OUTBOUND_LIFT_RUN.sts
                            , WrkStsType.OUTBOUND_LIFT_RUN_COMPLETE.sts
                    ));

            if (liftProtocol.getIOModeType().equals(LiftIoModeType.NONE)) {
                //未知模式
                if (!inWrkMasts.isEmpty()) {
                    liftThread.switchIOMode(LiftIoModeType.IN);
                } else if (!outWrkMasts.isEmpty()) {
                    liftThread.switchIOMode(LiftIoModeType.OUT);
                }else {
                    liftThread.switchIOMode(LiftIoModeType.IN);
                }
            } else if (liftProtocol.getIOModeType().equals(LiftIoModeType.IN)) {
                //入库模式
                if (inWrkMasts.isEmpty() && !outWrkMasts.isEmpty()) {
                    liftThread.switchIOMode(LiftIoModeType.OUT);
                }
            } else if (liftProtocol.getIOModeType().equals(LiftIoModeType.OUT)) {
                //出库模式
                if (outWrkMasts.isEmpty() && !inWrkMasts.isEmpty()) {
                    liftThread.switchIOMode(LiftIoModeType.IN);
                }
            }
        }
    }

}