Merge remote-tracking branch 'origin/shuttle_rcs' into shuttle_rcs

taisheng

5 天以前 a5fd6b72f8342f0228321849b04c822feba2d2a0

Merge remote-tracking branch 'origin/shuttle_rcs' into shuttle_rcs

 src/main/java/com/zy/asrs/controller/ConsoleController.java

@@ -7,17 +7,26 @@
import com.core.common.R;
import com.zy.asrs.domain.param.SystemSwitchParam;
import com.zy.asrs.entity.BasMap;
import com.zy.asrs.entity.WrkMast;
import com.zy.asrs.service.BasMapService;
import com.zy.asrs.service.WrkMastService;
import com.zy.common.model.MapNode;
import com.zy.common.model.enums.NavigationMapType;
import com.zy.common.utils.NavigateMapData;
import com.zy.common.utils.RedisUtil;
import com.zy.core.cache.SlaveConnection;
import com.zy.core.enums.RedisKeyType;
import com.zy.core.enums.SlaveType;
import com.zy.core.model.ForkLiftSlave;
import com.zy.core.model.ShuttleSlave;
import com.zy.core.model.protocol.ForkLiftProtocol;
import com.zy.core.model.protocol.ShuttleProtocol;
import com.zy.core.properties.SlaveProperties;
import com.zy.core.properties.SystemProperties;
import com.zy.core.thread.ForkLiftThread;
import com.zy.core.thread.ShuttleThread;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpServletRequest;
@@ -33,15 +42,15 @@
public class ConsoleController {

    @Autowired
    private SlaveProperties slaveProperties;
    @Autowired
    private BasMapService basMapService;
    @Autowired
    private RedisUtil redisUtil;
    @Value("${super.pwd}")
    private String superPwd;
    @Autowired
    private NavigateMapData navigateMapData;
    @Autowired
    private WrkMastService wrkMastService;
    @Autowired
    private SlaveProperties slaveProperties;

    @PostMapping("/system/running/status")
    @ManagerAuth(memo = "系统运行状态")
@@ -122,4 +131,48 @@
        return R.ok();
    }

    /**
     * 任务检测
     */
    @GetMapping("/checkTask")
    @ManagerAuth(memo = "任务检测")
    public R checkTask() {
        List<WrkMast> wrkMasts = wrkMastService.selectList(new EntityWrapper<>());
        if (!wrkMasts.isEmpty()) {
            return R.error("存在未结束任务");
        }

        for (ShuttleSlave slave : slaveProperties.getShuttle()) {
            ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, slave.getId());
            if (shuttleThread == null) {
                continue;
            }
            ShuttleProtocol shuttleProtocol = shuttleThread.getStatus();
            if (shuttleProtocol == null) {
                continue;
            }

            if (shuttleProtocol.getTaskNo() > 0) {
                return R.error(slave.getId() + "号小车存在工作号");
            }
        }

        for (ForkLiftSlave slave : slaveProperties.getForkLift()) {
            ForkLiftThread forkLiftThread = (ForkLiftThread) SlaveConnection.get(SlaveType.ForkLift, slave.getId());
            if (forkLiftThread == null) {
                continue;
            }
            ForkLiftProtocol forkLiftProtocol = forkLiftThread.getStatus();
            if (forkLiftProtocol == null) {
                continue;
            }

            if (forkLiftProtocol.getTaskNo() > 0) {
                return R.error(slave.getId() + "号货叉提升机存在工作号");
            }
        }

        return R.ok();
    }

}

 src/main/java/com/zy/asrs/mapper/WrkMastMapper.java

@@ -28,14 +28,14 @@

    List<WrkMast> selectBy2125();

    //查询指定楼层待分配车辆的任务
    List<WrkMast> selectNoShuttleWrkByLev(String lev);
    //查询指定楼层任务
    List<WrkMast> selectWrkByLev(String lev);

    List<WrkMast> selectShuttleWrkByLev(String lev);

    List<WrkMast> selectShuttleOutWrkByLev(String lev);

    WrkMast selectLiftWrkMast(Integer liftNo);
    List<WrkMast> selectLiftWrkMast(Integer liftNo);

    List<WrkMast> selectLocToLocWrkMast();//查询库位移转工作档


 src/main/java/com/zy/asrs/service/WrkMastService.java

@@ -11,8 +11,8 @@

    Boolean judgeInbound(WrkMast wrkMast);

    //查询指定楼层待分配车辆的任务
    List<WrkMast> selectNoShuttleWrkByLev(Integer lev);
    //查询指定楼层任务
    List<WrkMast> selectWrkByLev(Integer lev);

    //查询指定楼层已分配车辆的任务
    List<WrkMast> selectShuttleWrkByLev(Integer lev);
@@ -32,6 +32,6 @@

    List<WrkMast> selectShuttleMoveWrk();

    WrkMast selectLiftWrkMast(Integer liftNo);
    List<WrkMast> selectLiftWrkMast(Integer liftNo);

}

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

@@ -444,9 +444,13 @@
                            //102.小车搬运中 ==> 103.小车搬运完成
                            wrkMast.setWrkSts(WrkStsType.OUTBOUND_SHUTTLE_RUN_COMPLETE.sts);
                            shuttleThread.setSyncTaskNo(0);
                        } else if (wrkMast.getWrkSts() == WrkStsType.MOVE_SITE.sts) {
                            //302.小车移动至站点 ==> 303.小车移动至站点完成
                            wrkMast.setWrkSts(WrkStsType.MOVE_SITE_COMPLETE.sts);
                        } else if (wrkMast.getWrkSts() == WrkStsType.MOVE_NEARBY.sts) {
                            //302.小车移动至近点中 ==> 303.小车移动至近点完成
                            wrkMast.setWrkSts(WrkStsType.MOVE_NEARBY_COMPLETE.sts);
                            shuttleThread.setSyncTaskNo(0);
                        } else if (wrkMast.getWrkSts() == WrkStsType.MOVE_IN_LIFT.sts) {
                            //304.小车迁入提升机中 ==> 305.小车迁入提升机完成
                            wrkMast.setWrkSts(WrkStsType.MOVE_IN_LIFT_COMPLETE.sts);
                            shuttleThread.setSyncTaskNo(0);
                        } else if (wrkMast.getWrkSts() == WrkStsType.MOVE_OUT_LIFT.sts) {
                            //308.小车迁出提升机中 ==> 309.小车迁出提升机完成
@@ -681,6 +685,14 @@
                    News.taskInfo(wrkMast.getWrkNo(), "{}任务，未找到匹配的提升机", wrkMast.getWrkNo());
                    return false;
                }

                //申请提升机资源
                boolean applyForkLift = forkLiftAction.applyForkLift(liftNo, wrkMast.getWrkNo());
                if(!applyForkLift) {
                    News.taskInfo(wrkMast.getWrkNo(), "{}任务，申请提升机资源失败，禁止入库", wrkMast.getWrkNo());
                    return false;
                }
                return false;
            }

            ForkLiftThread forkLiftThread = (ForkLiftThread) SlaveConnection.get(SlaveType.ForkLift, liftNo);
@@ -700,15 +712,6 @@
            if (!forkLiftProtocol.getIOModeType().equals(ForkLiftIoModeType.IN)) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，提升机不处于入库模式，禁止入库", wrkMast.getWrkNo());
                return false;
            }

            //判断提升机是否有其他任务
            WrkMast liftWrkMast = wrkMastService.selectLiftWrkMast(wrkMast.getLiftNo());
            if (liftWrkMast != null) {
                if (!liftWrkMast.getWrkNo().equals(wrkMast.getWrkNo())) {//提升机任务和当前任务不相同
                    News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}号提升机，提升机存在未完成任务，禁止派发", wrkMast.getWrkNo(), wrkMast.getLiftNo());
                    return false;//当前提升机存在未完成任务，等待下一次轮询
                }
            }

            //检测楼层是否有可用穿梭车
@@ -754,7 +757,6 @@
            assignCommand.setTaskMode(ForkLiftTaskModeType.PICK_PUT.id.shortValue());

            wrkMast.setWrkSts(WrkStsType.INBOUND_LIFT_RUN.sts);//提升机搬运中  1.生成入库任务 ==> 3.提升机搬运中
            wrkMast.setLiftNo(liftNo);
            wrkMast.setSystemMsg("");//清空消息
            wrkMast.setModiTime(now);
            if (wrkMastService.updateById(wrkMast)) {
@@ -835,6 +837,13 @@
                    News.taskInfo(wrkMast.getWrkNo(), "{}任务，未找到匹配的提升机", wrkMast.getWrkNo());
                    return false;
                }
                //申请提升机资源
                boolean applyForkLift = forkLiftAction.applyForkLift(liftSta.getLiftNo(), wrkMast.getWrkNo());
                if(!applyForkLift) {
                    News.taskInfo(wrkMast.getWrkNo(), "{}任务，申请提升机资源失败，禁止执行出库", wrkMast.getWrkNo());
                    return false;
                }
                return false;
            }

            ForkLiftThread forkLiftThread = (ForkLiftThread) SlaveConnection.get(SlaveType.ForkLift, liftNo);
@@ -854,15 +863,6 @@
            if (!forkLiftProtocol.getIOModeType().equals(ForkLiftIoModeType.OUT)) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，提升机不处于出库模式，禁止出库", wrkMast.getWrkNo());
                return false;
            }

            //判断提升机是否有其他任务
            WrkMast liftWrkMast = wrkMastService.selectLiftWrkMast(wrkMast.getLiftNo());
            if (liftWrkMast != null) {
                if (!liftWrkMast.getWrkNo().equals(wrkMast.getWrkNo())) {//提升机任务和当前任务不相同
                    News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}号提升机，提升机存在未完成任务，禁止派发", wrkMast.getWrkNo(), wrkMast.getLiftNo());
                    return false;//当前提升机存在未完成任务，等待下一次轮询
                }
            }

            //请求上级系统，是否允许出库
@@ -885,7 +885,6 @@
            assignCommand.setTaskMode(ForkLiftTaskModeType.PICK_PUT.id.shortValue());

            wrkMast.setWrkSts(WrkStsType.OUTBOUND_LIFT_RUN.sts);//提升机搬运中  103.生成入库任务 ==> 104.提升机搬运中
            wrkMast.setLiftNo(liftNo);
            wrkMast.setShuttleNo(null);//释放小车
            wrkMast.setSystemMsg("");//清空消息
            wrkMast.setModiTime(new Date());
@@ -1448,8 +1447,13 @@
            //查询小车移库任务
            List<WrkMast> wrkMasts = wrkMastService.selectShuttleMoveWrk();
            for (WrkMast wrkMast : wrkMasts) {
                boolean stepMoveSta = this.shuttleMoveExecuteStepMoveSta(wrkMast);//小车移动到站点
                if (!stepMoveSta) {
                boolean stepMoveNearby = this.shuttleMoveExecuteStepMoveNearby(wrkMast);//小车移动到近点
                if (!stepMoveNearby) {
                    continue;
                }

                boolean stepMoveInLift = this.shuttleMoveExecuteStepMoveInLift(wrkMast);//小车迁入提升机中
                if (!stepMoveInLift) {
                    continue;
                }

@@ -1475,15 +1479,15 @@
    }

    /**
     * 小车迁移-小车移动到站点
     * 小车迁移-小车移动到近点中
     * 如需主方法执行continue，请返回false
     * ps:返回值true并不代表该方法执行成功，返回值仅做标记用于主方法是否执行continue
     */
    private boolean shuttleMoveExecuteStepMoveSta(WrkMast wrkMast) {
        //--------------------------------------小车移动至站点-----------------------------------------//
    private boolean shuttleMoveExecuteStepMoveNearby(WrkMast wrkMast) {
        //--------------------------------------小车移动到近点中-----------------------------------------//
        Date now = new Date();

        //小车移动至站点  301.生成小车移库任务 ==> 302.小车移动至站点中
        //小车移动到近点  301.生成小车移库任务 ==> 302.小车移动至站点中
        if (wrkMast.getWrkSts() == WrkStsType.NEW_MOVE.sts) {
            //获取四向穿梭车线程
            ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, wrkMast.getShuttleNo());
@@ -1544,38 +1548,111 @@
                return false;
            }

            if (wrkMast.getLiftNo() == null) {
                //判断提升机是否有其他任务(该任务需要换层必须提前独占提升机)
                WrkMast liftWrkMast = wrkMastService.selectLiftWrkMast(liftSta.getLiftNo());
                if (liftWrkMast != null) {
                    News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}号提升机，提升机存在未完成任务，禁止派发", wrkMast.getWrkNo(), liftSta.getLiftNo());
                    return false;//当前提升机存在未完成任务，等待下一次轮询
                }
            ShuttleAssignCommand assignCommand = new ShuttleAssignCommand();
            assignCommand.setShuttleNo(shuttleProtocol.getShuttleNo()); // 四向穿梭车编号
            assignCommand.setTaskMode(ShuttleTaskModeType.MOVE_LOC_NO.id);//小车移库任务
            assignCommand.setTaskNo(wrkMast.getWrkNo());//任务号
            assignCommand.setAuto(true);//自动模式

                wrkMast.setModiTime(now);
                wrkMast.setLiftNo(liftSta.getLiftNo());//提前锁定提升机
                wrkMast.setSystemMsg("");//清空消息
                wrkMastService.updateById(wrkMast);
            //计算近点位置
            String endLocation = navigateUtils.calcEndLocation(shuttleProtocol.getCurrentLocNo(), liftSta.getLocNo(), NavigationMapType.NORMAL.id, null, null, 1);
            if (endLocation == null) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，小车近点位置计算失败", wrkMast.getWrkNo());
                return false;
            }

            //*************尝试锁定目标站路径***************
            List<NavigateNode> targetNodes = ForkLiftUtils.getLiftStaNodes(wrkMast.getStaNo());
            if (targetNodes == null) {
                return false;//未获取到节点
            //获取小车到近点行走命令
            List<ShuttleCommand> commands = shuttleOperaUtils.getStartToTargetCommands(shuttleProtocol.getCurrentLocNo(), endLocation, NavigationMapType.NORMAL.id, assignCommand, shuttleThread);
            if (commands == null) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}小车，路径计算失败", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                return false;//路径解锁失败
            }
            boolean checkPathIsAvailable = navigateUtils.checkPathIsAvailable(targetNodes, shuttleProtocol.getShuttleNo(), Utils.getLev(wrkMast.getLocNo()));
            if (!checkPathIsAvailable) {
                News.info("{}任务，{}小车，目标站点路径被占用，禁止派发", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                return false;//检测目标站点路径是否未被占用

            assignCommand.setCommands(commands);

            wrkMast.setWrkSts(WrkStsType.MOVE_NEARBY.sts);//小车移动到提升机中  301.生成小车移库任务 ==> 302.小车移动至近点中
            wrkMast.setModiTime(now);
            wrkMast.setSystemMsg("");//清空消息
            if (wrkMastService.updateById(wrkMast)) {
                //下发任务
                shuttleAction.assignWork(shuttleProtocol.getShuttleNo(), assignCommand);
                notifyUtils.notify(String.valueOf(SlaveType.Shuttle), shuttleProtocol.getShuttleNo(), String.valueOf(wrkMast.getWrkNo()), wrkMast.getWmsWrkNo(), NotifyMsgType.SHUTTLE_MOVING);
                //触发通知
                return false;
            }
            //尝试锁定目标站路径
            boolean result2 = navigateMapUtils.writeNavigateNodeToRedisMap(Utils.getLev(wrkMast.getLocNo()), shuttleProtocol.getShuttleNo(), targetNodes, true);//所使用的路径进行锁定禁用
            if (!result2) {
                News.info("{}任务，{}小车，路径锁定失败，禁止派发", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                return false;//路径锁定失败
            return false;
        }
        return true;
    }

    /**
     * 小车迁移-小车迁入提升机中
     * 如需主方法执行continue，请返回false
     * ps:返回值true并不代表该方法执行成功，返回值仅做标记用于主方法是否执行continue
     */
    private boolean shuttleMoveExecuteStepMoveInLift(WrkMast wrkMast) {
        //--------------------------------------小车迁入提升机中-----------------------------------------//
        Date now = new Date();

        //小车迁入提升机  303.小车移动至近点完成 ==> 304.小车迁入提升机中
        if (wrkMast.getWrkSts() == WrkStsType.MOVE_NEARBY_COMPLETE.sts) {
            //获取四向穿梭车线程
            ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, wrkMast.getShuttleNo());
            if (shuttleThread == null) {
                return false;
            }
            //*************尝试锁定目标站路径***************
            ShuttleProtocol shuttleProtocol = shuttleThread.getStatus();
            if (shuttleProtocol == null) {
                return false;
            }

            //小车处于空闲状态
            if (!shuttleThread.isIdle()) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}小车，小车忙碌中", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                return false;
            }

            //获取源输送站
            ForkLiftStaProtocol liftSta = ForkLiftUtils.getLiftStaByStaNo(wrkMast.getSourceStaNo());
            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;
            }

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

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

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

            if (wrkMast.getLiftNo() == null) {
                //申请提升机资源(该任务需要换层必须提前独占提升机)
                boolean applyForkLift = forkLiftAction.applyForkLift(liftSta.getLiftNo(), wrkMast.getWrkNo());
                if(!applyForkLift) {
                    News.taskInfo(wrkMast.getWrkNo(), "{}任务，申请提升机资源失败，禁止移动至站点", wrkMast.getWrkNo());
                    return false;
                }
                return false;
            }

            ShuttleAssignCommand assignCommand = new ShuttleAssignCommand();
            assignCommand.setShuttleNo(shuttleProtocol.getShuttleNo()); // 四向穿梭车编号
@@ -1583,19 +1660,16 @@
            assignCommand.setTaskNo(wrkMast.getWrkNo());//任务号
            assignCommand.setAuto(true);//自动模式

            //获取小车到输送站点行走命令
            //获取小车到提升机行走命令
            List<ShuttleCommand> commands = shuttleOperaUtils.getStartToTargetCommands(shuttleProtocol.getCurrentLocNo(), liftSta.getLocNo(), NavigationMapType.NORMAL.id, assignCommand, shuttleThread);
            if (commands == null) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}小车，路径计算失败", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());

                //所使用的路径进行锁定禁用
                navigateMapUtils.writeNavigateNodeToRedisMap(Utils.getLev(wrkMast.getLocNo()), shuttleProtocol.getShuttleNo(), targetNodes, false);
                return false;//路径解锁失败
            }

            assignCommand.setCommands(commands);

            wrkMast.setWrkSts(WrkStsType.MOVE_SITE.sts);//小车移动到提升机中  301.生成小车移库任务 ==> 302.小车移动至站点
            wrkMast.setWrkSts(WrkStsType.MOVE_IN_LIFT.sts);//303.小车移动至近点完成 ==> 304.小车迁入提升机中
            wrkMast.setModiTime(now);
            wrkMast.setSystemMsg("");//清空消息
            if (wrkMastService.updateById(wrkMast)) {
@@ -1619,8 +1693,8 @@
        //--------------------------------------提升机搬运中-----------------------------------------//
        Date now = new Date();

        //提升机搬运中  303.小车移动至站点完成 ==> 306.提升机搬运中
        if (wrkMast.getWrkSts() == WrkStsType.MOVE_SITE_COMPLETE.sts) {
        //提升机搬运中  305.小车迁入提升机完成 ==> 306.提升机搬运中
        if (wrkMast.getWrkSts() == WrkStsType.MOVE_IN_LIFT_COMPLETE.sts) {
            ForkLiftThread forkLiftThread = (ForkLiftThread) SlaveConnection.get(SlaveType.ForkLift, wrkMast.getLiftNo());
            if (forkLiftThread == null) {
                return false;
@@ -1632,14 +1706,6 @@
            if (!forkLiftThread.isIdle()) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}号提升机，提升机忙碌中，禁止派发", wrkMast.getWrkNo(), wrkMast.getLiftNo());
                return false;
            }
            //判断提升机是否有其他任务
            WrkMast liftWrkMast = wrkMastService.selectLiftWrkMast(wrkMast.getLiftNo());
            if (liftWrkMast != null) {
                if (!liftWrkMast.getWrkNo().equals(wrkMast.getWrkNo())) {//提升机任务和当前任务不相同
                    News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}号提升机，提升机存在未完成任务，禁止派发", wrkMast.getWrkNo(), wrkMast.getLiftNo());
                    return false;//当前提升机存在未完成任务，等待下一次轮询
                }
            }

            //获取源站
@@ -1668,7 +1734,7 @@
            assignCommand.setTaskNo(wrkMast.getWrkNo().shortValue());
            assignCommand.setTaskMode(ForkLiftTaskModeType.SHUTTLE_SWITCH.id.shortValue());

            wrkMast.setWrkSts(WrkStsType.MOVE_LIFT_RUN.sts);//提升机搬运中  303.小车移动至站点完成 ==> 306.提升机搬运中
            wrkMast.setWrkSts(WrkStsType.MOVE_LIFT_RUN.sts);//提升机搬运中  305.小车迁入提升机完成 ==> 306.提升机搬运中
            wrkMast.setSystemMsg("");//清空消息
            wrkMast.setModiTime(now);
            if (wrkMastService.updateById(wrkMast)) {
@@ -1778,30 +1844,8 @@
            assignCommand.setSourceLocNo(shuttleProtocol.getCurrentLocNo());//源库位
            assignCommand.setLocNo(wrkMast.getLocNo());//目标库位

            List<ShuttleCommand> commands = null;
            //跨楼层移动任务
            if (Utils.getLev(wrkMast.getSourceLocNo()) != Utils.getLev(wrkMast.getLocNo())) {
                if (Utils.getLev(shuttleProtocol.getCurrentLocNo()) != Utils.getLev(wrkMast.getLocNo())) {
                    return false;//小车未到达目标层
                }

                //需要将前两个节点作为白名单节点传入
                List<NavigateNode> targetNodes = ForkLiftUtils.getLiftStaNodes(wrkMast.getStaNo());
                if (targetNodes == null) {
                    return false;//未获取到节点
                }

                //设置计算节点的白名单
                ArrayList<int[]> whiteList = new ArrayList<>();//设置计算节点的白名单
                for (NavigateNode node : targetNodes) {
                    whiteList.add(new int[]{node.getX(), node.getY()});
                }
                commands = shuttleOperaUtils.getStartToTargetCommands(shuttleProtocol.getCurrentLocNo(), wrkMast.getLocNo(), NavigationMapType.NORMAL.id, whiteList, assignCommand, shuttleThread);
            }else {
                //获取小车到目标库位命令
                commands = shuttleOperaUtils.getStartToTargetCommands(shuttleProtocol.getCurrentLocNo(), wrkMast.getLocNo(), NavigationMapType.NORMAL.id, assignCommand, shuttleThread);
            }

            //获取小车到目标库位命令
            List<ShuttleCommand> commands = shuttleOperaUtils.getStartToTargetCommands(shuttleProtocol.getCurrentLocNo(), wrkMast.getLocNo(), NavigationMapType.NORMAL.id, assignCommand, shuttleThread);
            if (commands == null) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}小车，路径计算失败", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                return false;//路径计算失败
@@ -1813,7 +1857,6 @@
            wrkMast.setLiftNo(null);//释放提升机
            wrkMast.setSystemMsg("");//清空消息
            wrkMast.setModiTime(now);

            if (wrkMastService.updateById(wrkMast)) {
                //下发任务
                shuttleAction.assignWork(shuttleProtocol.getShuttleNo(), assignCommand);
@@ -1940,9 +1983,9 @@
                continue;
            }

            //判断提升机是否有其他任务
            WrkMast liftWrkMast = wrkMastService.selectLiftWrkMast(wrkMast.getLiftNo());
            if (liftWrkMast != null) {
            //申请提升机资源
            boolean applyForkLift = forkLiftAction.applyForkLift(liftNo, null);
            if(!applyForkLift) {
                continue;//提升机已被绑定，不再执行预调度任务
            }


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

@@ -44,8 +44,8 @@
    }

    @Override
    public List<WrkMast> selectNoShuttleWrkByLev(Integer lev) {
        return this.baseMapper.selectNoShuttleWrkByLev("%" + lev);
    public List<WrkMast> selectWrkByLev(Integer lev) {
        return this.baseMapper.selectWrkByLev("%" + lev);
    }

    @Override
@@ -85,8 +85,8 @@
                , WrkStsType.OUTBOUND_LIFT_RUN_COMPLETE.sts

                , WrkStsType.NEW_MOVE.sts
                , WrkStsType.MOVE_SITE.sts
                , WrkStsType.MOVE_SITE_COMPLETE.sts
                , WrkStsType.MOVE_NEARBY.sts
                , WrkStsType.MOVE_NEARBY_COMPLETE.sts
                , WrkStsType.MOVE_IN_LIFT.sts
                , WrkStsType.MOVE_IN_LIFT_COMPLETE.sts
                , WrkStsType.MOVE_LIFT_RUN.sts
@@ -122,7 +122,7 @@
    }

    @Override
    public WrkMast selectLiftWrkMast(Integer liftNo) {
    public List<WrkMast> selectLiftWrkMast(Integer liftNo) {
        return this.baseMapper.selectLiftWrkMast(liftNo);
    }
}

 src/main/java/com/zy/common/utils/NavigateUtils.java

@@ -3,6 +3,7 @@
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.core.common.SpringUtils;
import com.core.exception.CoolException;
import com.zy.asrs.utils.Utils;
import com.zy.common.model.MapNode;
import com.zy.common.model.NavigateNode;
@@ -187,6 +188,54 @@
        return list;
    }

    //计算带末端段落路径
    public ArrayList<ArrayList<NavigateNode>> calcEndPath(String startPoint, String endPoint, Integer mapType, List<int[]> shuttlePoints, List<int[]> whites, int lastPathPart) {
        //计算路径
        List<NavigateNode> navigateNodes = calc(startPoint, endPoint, mapType, shuttlePoints, whites);
        if (navigateNodes == null) {
            News.error("{} dash {} can't find navigate path!", startPoint, endPoint);
            return null;
        }

        //获取分段路径
        ArrayList<ArrayList<NavigateNode>> partList = this.getSectionPath(navigateNodes);
        //根据传入的末端段落路径，找到末端点位
        int partResult = partList.size() - lastPathPart;
        if (partResult == 0) {//路径数量相同无需分割
            return partList;
        } else if (partResult < 0) {
            throw new CoolException("分段路径与末端路径数量计算异常");
        }
        int pathIdx = partResult - 1;
        ArrayList<ArrayList<NavigateNode>> filterList = new ArrayList<>();
        for (int i = 0; i <= pathIdx; i++) {
            filterList.add(partList.get(i));
        }
        return filterList;
    }

    //计算末端段落地址
    public String calcEndLocation(String startPoint, String endPoint, Integer mapType, List<int[]> shuttlePoints, List<int[]> whites, int lastPathPart) {
        ArrayList<ArrayList<NavigateNode>> endPath = calcEndPath(startPoint, endPoint, mapType, shuttlePoints, whites, lastPathPart);
        if (endPath == null) {
            return null;
        }

        return findTargetLocation(endPath);
    }

    public String findTargetLocation(List<NavigateNode> nodeList) {
        ArrayList<ArrayList<NavigateNode>> sectionPath = this.getSectionPath(nodeList);
        return findTargetLocation(sectionPath);
    }

    public String findTargetLocation(ArrayList<ArrayList<NavigateNode>> partList) {
        ArrayList<NavigateNode> nodes = partList.get(partList.size() - 1);
        NavigateNode targetNode = nodes.get(nodes.size() - 1);
        String locNo = NavigatePositionConvert.nodeToLocNo(targetNode);
        return locNo;
    }

    //判断当前节点到下一个节点是否为拐点
    public HashMap<String,Object> searchInflectionPoint(NavigateNode currentNode, NavigateNode fatherNode, NavigateNode nextNode) {
        HashMap<String, Object> map = new HashMap<>();

 src/main/java/com/zy/core/action/ForkLiftAction.java

@@ -154,4 +154,36 @@
        return response;
    }

    //申请提升机资源
    public synchronized boolean applyForkLift(Integer liftNo, Integer waitBindTaskNo) {
        ForkLiftThread forkLiftThread = (ForkLiftThread) SlaveConnection.get(SlaveType.ForkLift, liftNo);
        if (forkLiftThread == null) {
            return false;
        }
        ForkLiftProtocol forkLiftProtocol = forkLiftThread.getStatus();
        if (forkLiftProtocol == null) {
            return false;
        }
        if (!forkLiftThread.isIdle()) {
            return false;
        }

        List<WrkMast> wrkMasts = wrkMastService.selectLiftWrkMast(liftNo);
        if (!wrkMasts.isEmpty()) {
            return false;
        }

        if (waitBindTaskNo != null) {
            WrkMast wrkMast = wrkMastService.selectByWorkNo(waitBindTaskNo);
            if (wrkMast == null) {
                return false;
            }

            wrkMast.setLiftNo(liftNo);
            wrkMast.setModiTime(new Date());
            wrkMastService.updateById(wrkMast);
        }
        return true;
    }

}

 src/main/java/com/zy/core/dispatcher/ShuttleDispatchUtils.java

@@ -168,7 +168,8 @@
                    //当前穿梭车库位号
                    String currentLocNo = shuttleProtocol.getCurrentLocNo();
                    int currentLev = Utils.getLev(currentLocNo);
                    List<WrkMast> wrkMasts1 = wrkMastService.selectNoShuttleWrkByLev(currentLev);//判断当前穿梭车楼层是否有待分配车辆的任务，如果有则不分配这辆车
                    //判断当前楼层是否有任务，如果有则不分配这辆车
                    List<WrkMast> wrkMasts1 = wrkMastService.selectWrkByLev(currentLev);
                    int shuttleCount = this.getShuttleCountByLev(currentLev);//获取穿梭车楼层车辆数量
                    if (!wrkMasts1.isEmpty() && shuttleCount <= 1) {
                        //存在其他任务且可用小车数量小于等于1，跳过这辆车

 src/main/java/com/zy/core/enums/WrkStsType.java

@@ -29,8 +29,8 @@
    COMPLETE_CHARGE(210, "充电任务完成"),

    NEW_MOVE(301, "生成迁移任务"),
    MOVE_SITE(302, "小车移动至站点"),
    MOVE_SITE_COMPLETE(303, "小车移动至站点完成"),
    MOVE_NEARBY(302, "小车移动至近点中"),
    MOVE_NEARBY_COMPLETE(303, "小车移动至近点完成"),
    MOVE_IN_LIFT(304, "小车迁入提升机中"),
    MOVE_IN_LIFT_COMPLETE(305, "小车迁入提升机完成"),
    MOVE_LIFT_RUN(306, "提升机搬运中"),

 src/main/resources/mapper/WrkMastMapper.xml

@@ -73,10 +73,10 @@
        order by io_pri desc,wrk_sts desc
    </select>

    <select id="selectNoShuttleWrkByLev" resultMap="BaseResultMap">
    <select id="selectWrkByLev" resultMap="BaseResultMap">
        select * from asr_wrk_mast
        where shuttle_no is null
        and ((wrk_sts = 2 and loc_no like #{lev}) or (wrk_sts = 101 and source_loc_no like #{lev}))
        where 1=1
        and ((loc_no like #{lev}) or (source_loc_no like #{lev}))
        order by io_pri desc,wrk_sts desc
    </select>

@@ -97,8 +97,6 @@
    <select id="selectLiftWrkMast" resultMap="BaseResultMap">
        select * from asr_wrk_mast
        where lift_no = #{liftNo}
        and wrk_sts not in (9,10,109,110,210,311,410)
        limit 0,1
    </select>

    <select id="selectLocToLocWrkMast" resultMap="BaseResultMap">

 src/main/webapp/views/console.html

@@ -78,6 +78,7 @@
                    <div>
<!--                        <el-button @click="testMove()">测试移动车</el-button>-->
                        <el-button @click="resetMap()">重置地图</el-button>
                        <el-button @click="checkTask()">任务检测</el-button>
<!--                        <el-button @click="initLoc()">初始化库位</el-button>-->
                    </div>
                </div>
@@ -664,6 +665,30 @@
                            }
                        })
                    },
                    checkTask() {
                        let that = this
                        $.ajax({
                            url:baseUrl+"/console/checkTask",
                            headers:{
                                'token': localStorage.getItem('token')
                            },
                            data:{},
                            method:'get',
                            success:function (res) {
                                if (res.code === 200) {
                                    that.$message({
                                        message: res.msg,
                                        type: 'success'
                                    });
                                } else {
                                    that.$message({
                                        message: res.msg,
                                        type: 'error'
                                    });
                                }
                            }
                        })
                    },
                    initLev(){
                        let that = this
                        $.ajax({