#

Junjie

2023-11-20 83449fef571c247a2d73194b8063638349d0076a

#

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

@@ -737,6 +737,7 @@

            // 判断是否满足入库条件，自动、空闲、有物
            if (!(liftStaProtocol.getModel() && !liftStaProtocol.getBusy() && liftStaProtocol.getHasTray())) {
                News.info("{}任务，输送站点状态不满足入库。输送站点:{}", wrkMast.getWrkNo(), JSON.toJSONString(liftStaProtocol));
                continue;
            }

@@ -797,7 +798,8 @@
    public boolean shuttleInExecuteStep1(WrkMast wrkMast, LiftStaProtocol liftStaProtocol) {
        if (wrkMast.getWrkSts() == 4) {
            if (wrkMast.getShuttleNo() == null) {//没有绑定小车，进行调度
                shuttleDispatchUtils.dispatchShuttle(wrkMast.getWrkNo(), liftStaProtocol.getLocNo());//调度小车到货物所在输送站点进行取货
                boolean result = shuttleDispatchUtils.dispatchShuttle(wrkMast.getWrkNo(), liftStaProtocol.getLocNo());//调度小车到货物所在输送站点进行取货
                News.info("{}任务，调度小车{}系统等待中", wrkMast.getWrkNo(), result ? "成功" : "失败");
                return false;
            }

@@ -811,16 +813,19 @@
                return false;
            }
            if (!shuttleProtocol.isIdle()) {
                News.info("{}任务，{}小车忙碌中", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                return false;
            }
            //判断小车令牌是否未被占领
            if (shuttleProtocol.getToken() != 0) {
                News.info("{}任务，{}小车，令牌已被独占，禁止派发任务", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                return false;//小车已被独占，禁止再派发任务
            }

            //判断小车是否存在移动任务
            WrkMast hasMoveWorking = wrkMastMapper.selectShuttleHasMoveWorking(wrkMast.getShuttleNo());
            if (hasMoveWorking != null) {
                News.info("{}任务，{}小车，存在移动任务，禁止派发任务", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                return false;//存在移动任务，禁止执行入库任务
            }

@@ -828,12 +833,14 @@
            if (!shuttleProtocol.getCurrentLocNo().equals(liftStaProtocol.getLocNo())) {
                //小车不在输送站点位置
                shuttleDispatchUtils.dispatchShuttle(wrkMast.getWrkNo(), liftStaProtocol.getLocNo(), wrkMast.getShuttleNo());//调度小车到货物所在输送站点进行取货
                News.info("{}任务，{}小车，未到达输送站点，系统等待中", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                return false;
            }

            //小车已抵达输送站点位置，进行搬运货物
            NyShuttleOperaResult result = NyShuttleOperaUtils.getShuttleTransportCommands(wrkMast.getShuttleNo(), wrkMast.getWrkNo(), shuttleProtocol.getCurrentLocNo(), wrkMast.getLocNo());
            if (result == null) {//路径计算失败
                News.info("{}任务，{}小车，路径计算失败，系统等待中", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                return false;
            }

@@ -884,6 +891,7 @@
            wrapper.eq("stn_no", wrkMast.getStaNo());//出库站点编号
            StaDesc staDesc = staDescService.selectOne(wrapper);
            if (staDesc == null) {
                News.info("{}任务，出库路径不存在", wrkMast.getWrkNo());
                return false;//出库路径不存在
            }

@@ -894,16 +902,19 @@
            }

            if (!basDevp.getAutoing().equals("Y")) {
                News.info("{}任务，{}站点，不是自动状态",wrkMast.getWrkNo(),basDevp.getDevNo());
                return false;//不是自动状态
            }

            if (!basDevp.getOutEnable().equals("Y")) {
                News.info("{}任务，{}站点，没有可出信号", wrkMast.getWrkNo(), basDevp.getDevNo());
                return false;//出库站点不可出
            }

            Integer liftNo = basDevp.getLiftNo();//搜索出库提升机是否存在入库任务，如存在禁止出库
            List<WrkMast> liftWrkMasts = wrkMastMapper.selectInWrkMastByLiftNo(liftNo);
            if (!liftWrkMasts.isEmpty()) {
                News.info("{}任务，{}号提升机，存在入库任务，系统禁止出库", wrkMast.getWrkNo(), liftNo);
                return false;//存在入库任务，禁止出库
            }

@@ -914,11 +925,13 @@
            }

            if (!(liftStaProtocol.getModel() && !liftStaProtocol.getBusy() && !liftStaProtocol.getHasTray())) {
                News.info("{}任务，{}内部输送站，不满足自动、空闲、无托盘状态", wrkMast.getWrkNo(), liftStaProtocol.getStaNo());
                return false;//站点必须自动、空闲、没有托盘
            }

            if (wrkMast.getShuttleNo() == null) {//没有绑定小车，进行调度
                shuttleDispatchUtils.dispatchShuttle(wrkMast.getWrkNo(), wrkMast.getSourceLocNo());//调度小车到货物所在库位进行取货
                boolean result = shuttleDispatchUtils.dispatchShuttle(wrkMast.getWrkNo(), wrkMast.getSourceLocNo());//调度小车到货物所在库位进行取货
                News.info("{}任务，调度小车{}系统等待中。", wrkMast.getWrkNo(), result ? "成功" : "失败");
                return false;
            }

@@ -932,10 +945,12 @@
                return false;
            }
            if (!shuttleProtocol.isIdle()) {
                News.info("{}任务，{}小车，忙碌中", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                return false;
            }
            //判断小车令牌是否未被占领
            if (shuttleProtocol.getToken() != 0) {
                News.info("{}任务，{}小车，令牌已被独占，禁止派发任务", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                return false;//小车已被独占，禁止再派发任务
            }

@@ -943,12 +958,14 @@
            if (!shuttleProtocol.getCurrentLocNo().equals(wrkMast.getSourceLocNo())) {
                //小车不在输送站点位置
                shuttleDispatchUtils.dispatchShuttle(wrkMast.getWrkNo(), wrkMast.getSourceLocNo(), wrkMast.getShuttleNo());//调度小车到货物所在库位进行取货
                News.info("{}任务，{}小车，未到达输送站点，系统等待中", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                return false;
            }

            //小车已抵达货物位置，进行搬运货物
            NyShuttleOperaResult result = NyShuttleOperaUtils.getShuttleTransportCommands(wrkMast.getShuttleNo(), wrkMast.getWrkNo(), wrkMast.getSourceLocNo(), liftStaProtocol.getLocNo());//将货物搬运至提升机输送站点
            if (result == null) {//出库路径计算失败
                News.info("{}任务，{}小车，路径计算失败，系统等待中", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                return false;
            }

@@ -986,8 +1003,6 @@
            }

            //四向穿梭车状态为等待确认、小车处于空闲状态


            if (shuttleProtocol.getProtocolStatus() == ShuttleProtocolStatusType.WAITING.id  //任务完成等待确认
                    && shuttleProtocol.getTaskNo() != 0
                    && shuttleProtocol.getFree() == ShuttleStatusType.IDLE.id
@@ -1097,11 +1112,13 @@
            }

            if (!liftProtocol.isIdle()) {
                News.info("{}号提升机，忙碌中", liftSlave.getId());
                continue;
            }

            //判断提升机令牌是否被占用
            if (liftProtocol.getToken() != 0) {
                News.info("{}号提升机，令牌已被独占", liftSlave.getId());
                continue;
            }

@@ -1115,6 +1132,7 @@
                //搜索是否有其他任务占用了提升机，如果占用提升机的任务和当前任务相同，则运行执行
                WrkMast wrkMast1 = wrkMastMapper.selectLiftWrkMast(liftProtocol.getLiftNo().intValue());
                if (wrkMast1 != null && wrkMast1.getWrkNo().intValue() != wrkMast.getWrkNo().intValue()) {
                    News.info("{0}号提升机，被其他任务{1}占用且和当前任务{2}不相同，禁止派发", liftSlave.getId(), wrkMast1.getWrkNo(), wrkMast.getWrkNo());
                    continue;
                }

@@ -1150,6 +1168,7 @@
            }

            if (!sourceBasDevp.getInEnable().equals("Y")) {
                News.info("{}任务，{}源站，没有可入信号", wrkMast.getWrkNo(), sourceBasDevp.getDevNo());
                return false;//站点不可入
            }

@@ -1158,10 +1177,12 @@
            Integer outInModel2 = Utils.getOutInModelByLift(sourceBasDevp.getLiftNo(), 5);
            Integer outInModel3 = Utils.getOutInModelByLift(sourceBasDevp.getLiftNo(), 8);
            if (outInModel1 == null || outInModel2 == null || outInModel3 == null) {
                News.info("{}任务，没有出入库模式", wrkMast.getWrkNo());
                return false;//不存在出入库模式
            }

            if (outInModel1 == 2 || outInModel2 == 2 && outInModel3 == 2) {
                News.info("{}任务，有站点处于出库模式，禁止入库", wrkMast.getWrkNo());
                return false;//只要有一个处于出库模式，禁止入库
            }

@@ -1174,26 +1195,31 @@
                return false;
            }
            if (!liftProtocol.isIdle()) {
                News.info("{}任务，{}号提升机，忙碌中", wrkMast.getWrkNo(), liftProtocol.getLiftNo());
                return false;
            }
            //判断提升机令牌是否未被占领
            if (liftProtocol.getToken() != 0) {
                News.info("{}任务，{}号提升机，令牌已被独占，禁止派发", wrkMast.getWrkNo(), liftProtocol.getLiftNo());
                return false;//提升机已被独占，禁止再派发任务
            }

            //判断提升机内是否有小车
            if (liftProtocol.getHasCar()) {
                News.info("{}任务，{}号提升机，提升机内部有小车，禁止派发", wrkMast.getWrkNo(), liftProtocol.getLiftNo());
                return false;//有小车，禁止派发
            }

            //判断提升机内是否有托盘
            if (liftProtocol.getHasTray()) {
                News.info("{}任务，{}号提升机，提升机内部有托盘，禁止派发", wrkMast.getWrkNo(), liftProtocol.getLiftNo());
                return false;//有托盘，禁止派发
            }

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

@@ -1206,6 +1232,7 @@
            }

            if (targetStaProtocol.getHasTray()) {
                News.info("{}任务，{}号提升机，{}站点，提升机站点有托盘，禁止派发", wrkMast.getWrkNo(), liftProtocol.getLiftNo(), targetStaProtocol.getStaNo());
                return false;//提升机站点有托盘，禁止派发
            }

@@ -1262,12 +1289,14 @@
            //获取出库站点(目标站)
            BasDevp basDevp = basDevpService.selectById(wrkMast.getStaNo());
            if (basDevp == null) {
                News.info("{}任务，出库站点不存在，禁止派发", wrkMast.getWrkNo());
                return false;//出库站点不存在
            }

            //获取源站对应的牛眼提升机站点编号(起点编号)
            LiftStaProtocol liftStaProtocol = NyLiftUtils.getLiftStaByLev(basDevp.getLiftNo(), Utils.getLev(wrkMast.getSourceLocNo()));
            if (liftStaProtocol == null) {
                News.info("{}任务，找不到站点，禁止派发", wrkMast.getWrkNo());
                return false;//找不到站点
            }
            Integer startSta = liftStaProtocol.getStaNo();
@@ -1278,11 +1307,13 @@
                //调度小车避让
                boolean result = Utils.searchEmptyGroupToMoveShuttle(Utils.getLev(wrkMast.getSourceLocNo()), wrkMast.getShuttleNo(), shuttleThread);
                if (!result) {
                    News.info("{}任务，{}小车，小车在输送站点调度小车避让失败", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                    return false;
                }
            }

            if (!basDevp.getOutEnable().equals("Y")) {
                News.info("{}任务，{}站点，没有可出信号，禁止派发", wrkMast.getWrkNo(), basDevp.getDevNo());
                return false;//出库站点不可出
            }

@@ -1296,21 +1327,25 @@
            }

            if (!liftProtocol.isIdle()) {
                News.info("{}任务，{}号提升机，忙碌中", wrkMast.getWrkNo(), liftProtocol.getLiftNo());
                return false;
            }
            //判断提升机令牌是否未被占领
            if (liftProtocol.getToken() != 0) {
                News.info("{}任务，{}号提升机，令牌已被独占，禁止派发", wrkMast.getWrkNo(), liftProtocol.getLiftNo());
                return false;//提升机已被独占，禁止再派发任务
            }
            //判断提升机是否有其他任务
            WrkMast liftWrkMast = wrkMastMapper.selectLiftWrkMast(liftThread.getSlave().getId());
            if (liftWrkMast != null) {
                News.info("{}任务，{}号提升机，当前提升机存在未完成任务，禁止派发", wrkMast.getWrkNo(), liftProtocol.getLiftNo());
                return false;//当前提升机存在未完成任务，等待下一次轮询
            }

            //获目标站源站对应的输送站点
            BasDevp targetBasDevp = basDevpService.selectById(wrkMast.getStaNo());
            if (targetBasDevp == null) {
                News.info("{}任务，{}站点，站点不存在，禁止派发", wrkMast.getWrkNo(), wrkMast.getStaNo());
                return false;//站点不存在
            }
            //获取牛眼提升机站点编号(目标编号)
@@ -2648,7 +2683,7 @@
            wrkCharge.setShuttleNo(shuttle.getId());
            wrkCharge.setCharge(shuttleCharge.id);
            wrkCharge.setWrkNo(commonService.getChargeWorkNo(4));
            wrkCharge.setWrkSts(51L);   // 21.准备充电
            wrkCharge.setWrkSts(51L);   // 51.准备充电
            wrkCharge.setIoPri((double) 10);
            wrkCharge.setLocNo(chargeLocNo);
            wrkCharge.setMemo("charge");
@@ -2830,11 +2865,13 @@

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

            //判断小车令牌是否未被占领
            if (shuttleProtocol.getToken() != 0) {
                News.info("{}任务，{}小车，令牌已被独占，禁止派发", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                return false;//小车已被独占，禁止再派发任务
            }

@@ -2859,6 +2896,7 @@
            //判断提升机是否有其他任务(该任务需要换层必须提前独占提升机)
            WrkMast liftWrkMast = wrkMastMapper.selectLiftWrkMast(liftSta.getLiftNo());
            if (liftWrkMast != null) {
                News.info("{}任务，{}号提升机，提升机存在未完成任务，禁止派发", wrkMast.getWrkNo(), liftSta.getLiftNo());
                return false;//当前提升机存在未完成任务，等待下一次轮询
            }

@@ -2869,11 +2907,13 @@
            }
            boolean checkPathIsAvailable = NavigateUtils.checkPathIsAvailable(targetNodes, shuttleProtocol.getShuttleNo().intValue(), Utils.getLev(wrkMast.getLocNo()), null);
            if (!checkPathIsAvailable) {
                News.info("{}任务，{}小车，目标站点路径被占用，禁止派发", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                return false;//检测目标站点路径是否未被占用
            }
            //尝试锁定目标站路径
            boolean result2 = navigateMapUtils.writeNavigateNodeToRedisMap(Utils.getLev(wrkMast.getLocNo()), targetNodes, true);//所使用的路径进行锁定禁用
            if (!result2) {
                News.info("{}任务，{}小车，路径锁定失败，禁止派发", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                return false;//路径锁定失败
            }
            //*************尝试锁定目标站路径***************
@@ -2934,6 +2974,7 @@
            }

            if (basLift.getPoint() == null) {
                News.info("{}任务，{}号提升机，没有提升机点位坐标，禁止派发", wrkMast.getWrkNo(), basLift.getLiftNo());
                return false;//没有设置提升机点位坐标
            }

@@ -2941,6 +2982,7 @@
            WrkMast liftWrkMast = wrkMastMapper.selectLiftWrkMast(basLift.getLiftNo());
            if (liftWrkMast != null) {
                if (!liftWrkMast.getWrkNo().equals(wrkMast.getWrkNo())) {//提升机任务和当前任务不相同
                    News.info("{}任务，{}号提升机，提升机存在未完成任务，禁止派发", wrkMast.getWrkNo(), basLift.getLiftNo());
                    return false;//当前提升机存在未完成任务，等待下一次轮询
                }
            }
@@ -2955,6 +2997,7 @@
            }

            if (!liftProtocol.isIdle(wrkMast.getWrkNo().shortValue())) {
                News.info("{}任务，{}号提升机，提升机忙碌中，禁止派发", wrkMast.getWrkNo(), basLift.getLiftNo());
                return false;
            }

@@ -2970,11 +3013,13 @@

            //小车处于空闲状态
            if (!shuttleProtocol.isIdleNoCharge(wrkMast.getWrkNo())) {
                News.info("{}任务，{}小车，小车忙碌中，禁止派发", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                return false;
            }

            //小车令牌是否被任务独占
            if (!shuttleProtocol.getToken().equals(wrkMast.getWrkNo())) {
                News.info("{}任务，{}小车，小车令牌被独占，禁止派发", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                return false;
            }

@@ -2984,6 +3029,7 @@
                //调度提升机

                if (liftProtocol.getToken() != 0) {
                    News.info("{}任务，{}号提升机，提升机令牌被独占，禁止派发", wrkMast.getWrkNo(), liftProtocol.getLiftNo());
                    return false;//提升机令牌被占用
                }

@@ -3023,11 +3069,13 @@

            //判断提升机令牌是否为当前小车
            if (!liftProtocol.getToken().equals(wrkMast.getShuttleNo())) {
                News.info("{}任务，{}号提升机，提升机令牌被独占，禁止派发", wrkMast.getWrkNo(), liftProtocol.getLiftNo());
                return false;//提升机已被独占，禁止再派发任务
            }

            //判断小车是否为当前任务独占
            if (!shuttleProtocol.getToken().equals(wrkMast.getWrkNo())) {
                News.info("{}任务，{}小车，小车令牌被独占，禁止派发", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                return false;
            }

@@ -3090,23 +3138,27 @@
                return false;
            }
            if (!liftProtocol.isIdle(wrkMast.getWrkNo().shortValue())) {
                News.info("{}任务，{}号提升机，提升机忙碌中，禁止派发", wrkMast.getWrkNo(), liftProtocol.getLiftNo());
                return false;
            }
            //判断提升机是否有其他任务
            WrkMast liftWrkMast = wrkMastMapper.selectLiftWrkMast(liftThread.getSlave().getId());
            if (liftWrkMast != null) {
                if (!liftWrkMast.getWrkNo().equals(wrkMast.getWrkNo())) {//提升机任务和当前任务不相同
                    News.info("{}任务，{}号提升机，提升机存在未完成任务，禁止派发", wrkMast.getWrkNo(), liftProtocol.getLiftNo());
                    return false;//当前提升机存在未完成任务，等待下一次轮询
                }
            }

            //判断提升机令牌是否为当前小车
            if (!liftProtocol.getToken().equals(wrkMast.getShuttleNo())) {
                News.info("{}任务，{}号提升机，提升机令牌和当前小车不一致，禁止派发", wrkMast.getWrkNo(), liftProtocol.getLiftNo());
                return false;//提升机令牌和当前小车不一致，禁止派发
            }

            //判断提升机内是否有小车
            if (!liftProtocol.getHasCar()) {
                News.info("{}任务，{}号提升机，提升机内无小车，禁止派发", wrkMast.getWrkNo(), liftProtocol.getLiftNo());
                return false;//提升机内无小车
            }

@@ -3122,11 +3174,13 @@

            //小车处于空闲状态
            if (!shuttleProtocol.isIdleNoCharge()) {
                News.info("{}任务，{}号提升机，提升机忙碌中，禁止派发", wrkMast.getWrkNo(), liftProtocol.getLiftNo());
                return false;
            }

            //判断小车是否为当前任务独占
            if (!shuttleProtocol.getToken().equals(wrkMast.getWrkNo())) {
                News.info("{}任务，{}小车，小车当前任务未被独占，禁止派发", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                return false;
            }

@@ -3135,6 +3189,7 @@
            //获取目标站
            LiftStaProtocol liftSta = NyLiftUtils.getLiftStaByStaNo(wrkMast.getStaNo());
            if (sourceLiftSta == null || liftSta == null) {
                News.info("{}任务，缺少站点信息，禁止派发", wrkMast.getWrkNo());
                return false;//缺少站点信息
            }

@@ -3183,6 +3238,7 @@
                return false;
            }
            if (!liftProtocol.isIdle(wrkMast.getWrkNo().shortValue())) {
                News.info("{}任务，{}号提升机，提升机忙碌中，禁止派发", wrkMast.getWrkNo(), liftProtocol.getLiftNo());
                return false;
            }

@@ -3190,12 +3246,14 @@
            WrkMast liftWrkMast = wrkMastMapper.selectLiftWrkMast(liftThread.getSlave().getId());
            if (liftWrkMast != null) {
                if (!liftWrkMast.getWrkNo().equals(wrkMast.getWrkNo())) {//提升机任务和当前任务不相同
                    News.info("{}任务，{}号提升机，提升机存在未完成任务，禁止派发", wrkMast.getWrkNo(), liftProtocol.getLiftNo());
                    return false;//当前提升机存在未完成任务，等待下一次轮询
                }
            }

            //判断提升机令牌是否为当前小车
            if (!liftProtocol.getToken().equals(wrkMast.getShuttleNo())) {
                News.info("{}任务，{}号提升机，提升机令牌和当前小车不一致，禁止派发", wrkMast.getWrkNo(), liftProtocol.getLiftNo());
                return false;//提升机令牌和当前小车不一致，禁止派发
            }

@@ -3211,11 +3269,13 @@

            //小车处于空闲状态
            if (!shuttleProtocol.isIdleNoCharge()) {
                News.info("{}任务，{}小车，小车忙碌中，禁止派发", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                return false;
            }

            //判断小车是否为当前任务独占
            if (!shuttleProtocol.getToken().equals(wrkMast.getWrkNo())) {
                News.info("{}任务，{}小车，小车令牌被独占，禁止派发", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                return false;
            }

@@ -3231,6 +3291,7 @@
                return false;//没有提升机数据
            }
            if (basLift.getPoint() == null) {
                News.info("{}任务，{}号提升机，缺少提升机点位坐标，禁止派发", wrkMast.getWrkNo(), liftProtocol.getLiftNo());
                return false;//没有设置提升机点位坐标
            }

@@ -3290,11 +3351,13 @@

            //小车处于空闲状态
            if (!shuttleProtocol.isIdleNoCharge(wrkMast.getWrkNo())) {
                News.info("{}任务，{}小车，小车忙碌中，禁止派发", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                return false;
            }

            //判断小车令牌是否为当前任务
            if (shuttleProtocol.getToken() != 0 && !shuttleProtocol.getToken().equals(wrkMast.getWrkNo())) {
                News.info("{}任务，{}小车，小车令牌被独占，禁止派发", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                return false;
            }


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

@@ -4,13 +4,11 @@
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.core.common.SpringUtils;
import com.core.exception.CoolException;
import com.zy.asrs.entity.BasDevp;
import com.zy.asrs.entity.BasShuttle;
import com.zy.asrs.entity.WrkCharge;
import com.zy.asrs.entity.WrkMast;
import com.zy.asrs.mapper.WrkChargeMapper;
import com.zy.asrs.mapper.WrkMastMapper;
import com.zy.asrs.service.BasDevpService;
import com.zy.asrs.service.BasShuttleService;
import com.zy.asrs.service.WrkMastService;
import com.zy.asrs.utils.Utils;
@@ -55,13 +53,15 @@
    private WrkChargeMapper wrkChargeMapper;
    @Autowired
    private CommonService commonService;
    @Autowired
    private BasDevpService basDevpService;

    /**
     * 调度车辆-调度指定穿梭车
     */
    public boolean dispatchShuttle(Integer wrkNo, String locNo, Integer shuttleNo) {
        if (!checkCharge(shuttleNo, locNo)) {
            News.info("{}号小车，存在充电任务禁止小车移动任务调度", shuttleNo);
            return false;//存在充电任务暂停调度
        }
        return shuttleMoveGenerate(wrkNo, locNo, shuttleNo);
    }

@@ -92,8 +92,12 @@
                continue;
            }

            if (!checkChargeWrk(shuttle.getId())) {
                continue;//存在充电任务，过滤小车
            }

            if (!shuttleProtocol.isIdle()) {
                continue;
                continue;//小车忙碌中
            }

            if (shuttleProtocol.getSuspendState() == 1) {
@@ -160,6 +164,7 @@
                //检测目标楼层车数量是否小于允许的最大数量
                boolean checkDispatchMaxNum = checkDispatchMaxNum(lev);
                if (!checkDispatchMaxNum) {
                    News.info("{}任务，{}层，已经达到当前楼层调度车辆最大值", wrkMast1.getWrkNo(), lev);
                    return false;
                }

@@ -186,6 +191,7 @@
        }

        if (recentShuttle == null) {//没有搜索到可用穿梭车
            News.info("{}目标库位没有搜索到可用穿梭车", locNo);
            return false;
        }

@@ -202,50 +208,33 @@
        //获取四向穿梭车线程
        NyShuttleThread shuttleThread = (NyShuttleThread) SlaveConnection.get(SlaveType.Shuttle, shuttleNo);
        if (shuttleThread == null) {
            News.info("{}号小车，线程不存在", shuttleNo);
            return false;
        }
        NyShuttleProtocol shuttleProtocol = shuttleThread.getShuttleProtocol();
        if (shuttleProtocol == null) {
            News.info("{}号小车，线程不存在", shuttleNo);
            return false;
        }

        //小车处于空闲状态
        if (!shuttleProtocol.isIdleNoCharge()) {
            News.info("{}号小车，忙碌中", shuttleNo);
            return false;
        }

        //判断穿梭车是否存在未完成的小车移库任务
        WrkMast hasMoveWorking = wrkMastMapper.selectShuttleHasMoveWorking(shuttleNo);
        if (hasMoveWorking != null) {//小车存在移库任务，等待执行完成后再生成新的任务
            News.info("{}号小车，存在移动任务，等待执行完成后再生成新的任务", shuttleNo);
            return false;
        }

        //判断是否有其他任务正在使用穿梭车
        WrkMast wrkMast2 = wrkMastMapper.selectShuttleWorking(shuttleNo);
        if (wrkMast2 != null) {//小车存在其他工作档任务，等待执行完成后再生成新的任务
            News.info("{}号小车，存在其他工作档任务，等待执行完成再生成新的任务", shuttleNo);
            return false;
        }

        //判断是否有充电任务正在使用穿梭车
        WrkCharge wrkCharge = wrkChargeMapper.selectWorking(shuttleNo);
        if (wrkCharge != null) {//小车存在充电任务，等待执行完成后再生成新的任务
            //判断目标点是否为充电桩，如果是去充电则放行
            boolean toCharge = false;//去充电目标
            for (ShuttleChargeType chargeType : ShuttleChargeType.values()) {
                if (chargeType.locNo.equals(locNo)) {
                    toCharge = true;//去充电桩
                    break;
                }
            }

            if (wrkCharge.getWrkSts() == 53) {
                toCharge = true;//充电结束，允许生成移库任务
            }

            if (!toCharge) {
                //不是去充电桩且存在充电任务，禁止生成新的移动任务
                return false;
            }
        }

        Integer sourceStaNo = null;//小车换层源站点
@@ -255,6 +244,7 @@
            //获取穿梭车最近且空闲的提升机输送站点
            LiftStaProtocol liftSta = this.getRecentLiftSta(shuttleNo, Utils.getLev(locNo));
            if (liftSta == null) {
                News.info("{}号小车，{}目标库位，没有可用空闲输送站点", shuttleNo, locNo);
                return false;//没有可用且空闲的输送站点
            }
            sourceStaNo = liftSta.getStaNo();//源站点
@@ -434,4 +424,47 @@
        return recentSta;
    }

    /**
     * 检测是否穿梭车是否有充电任务
     */
    public boolean checkChargeWrk(int shuttleNo) {
        //判断是否有充电任务正在使用穿梭车
        WrkCharge wrkCharge = wrkChargeMapper.selectWorking(shuttleNo);
        if (wrkCharge != null) {
            return true;//有充电任务
        }
        return false;//无充电任务
    }

    /**
     * 检测穿梭车是否有充电任务，目标点是否为充电桩位置
     * @param shuttleNo 小车号
     * @param locNo 目标位置
     */
    public boolean checkCharge(int shuttleNo, String locNo) {
        //判断是否有充电任务正在使用穿梭车
        WrkCharge wrkCharge = wrkChargeMapper.selectWorking(shuttleNo);
        if (wrkCharge != null) {//小车存在充电任务，等待执行完成后再生成新的任务
            //判断目标点是否为充电桩，如果是去充电则放行
            boolean toCharge = false;//去充电目标
            for (ShuttleChargeType chargeType : ShuttleChargeType.values()) {
                if (chargeType.locNo.equals(locNo)) {
                    toCharge = true;//去充电桩
                    break;
                }
            }

            if (wrkCharge.getWrkSts() == 53) {
                toCharge = true;//充电结束，允许生成移库任务
            }

            if (!toCharge) {
                //不是去充电桩且存在充电任务，禁止生成新的移动任务
                return false;
            }
        }

        return true;//无充电任务放行 || 去充电桩中放行
    }

}

 src/main/java/com/zy/core/model/protocol/NyShuttleProtocol.java

@@ -484,21 +484,22 @@
                && this.taskNo == 0
                && this.protocolStatus == ShuttleProtocolStatusType.IDLE.id
                ;
        if (!res) {
            return res;
        } else {
            // 电量
            try {
                Integer chargeLine = SpringUtils.getBean(BasShuttleService.class).selectById(this.shuttleNo).getChargeLine();
                if (chargeLine == null) {
                    return false;
                }
                return this.getPowerPercent() >= chargeLine;
            } catch (Exception e) {
                News.error("fail", e);
                return false;
            }
        }
        return res;
//        if (!res) {
//            return res;
//        } else {
//            // 电量
//            try {
//                Integer chargeLine = SpringUtils.getBean(BasShuttleService.class).selectById(this.shuttleNo).getChargeLine();
//                if (chargeLine == null) {
//                    return false;
//                }
//                return this.getPowerPercent() >= chargeLine;
//            } catch (Exception e) {
//                News.error("fail", e);
//                return false;
//            }
//        }
    }

    // 是否处于空闲待命状态，传入的taskNo和当前taskNo相同时允许放行
@@ -509,18 +510,19 @@
                && (this.taskNo == 0 || this.taskNo == taskNo)
                && this.protocolStatus.intValue() == ShuttleProtocolStatusType.IDLE.id
                ;
        if (!res) {
            return res;
        } else {
            // 电量
            try {
                Integer chargeLine = SpringUtils.getBean(BasShuttleService.class).selectById(this.shuttleNo).getChargeLine();
                return this.getPowerPercent() > chargeLine;
            } catch (Exception e) {
                News.error("fail", e);
                return false;
            }
        }
        return res;
//        if (!res) {
//            return res;
//        } else {
//            // 电量
//            try {
//                Integer chargeLine = SpringUtils.getBean(BasShuttleService.class).selectById(this.shuttleNo).getChargeLine();
//                return this.getPowerPercent() > chargeLine;
//            } catch (Exception e) {
//                News.error("fail", e);
//                return false;
//            }
//        }
    }

    // 是否处于空闲待命状态

 src/main/java/com/zy/core/thread/NyShuttleThread.java

@@ -113,12 +113,6 @@

    private void readStatus() {
        try {
            if (null == shuttleProtocol) {
                shuttleProtocol = new NyShuttleProtocol();
                shuttleProtocol.setShuttleNo(slave.getId().shortValue());
                shuttleProtocol.setProtocolStatus(ShuttleProtocolStatusType.IDLE);
            }

            //----------读取四向穿梭车状态-----------
            NyShuttleHttpCommand readStatusCommand = NyHttpUtils.getReadStatusCommand(slave.getId());
            JSONObject jsonObject = NyHttpUtils.requestCommand(socket, readStatusCommand);
@@ -247,6 +241,7 @@
                    OutputQueue.SHUTTLE.offer(MessageFormat.format("【{0}】[id:{1}] <<<<< 实时数据更新成功",DateUtils.convert(new Date()), slave.getId()));
//                    log.info(MessageFormat.format("【{0}】[id:{1}] <<<<< 实时数据更新成功",DateUtils.convert(new Date()), slave.getId()));
                }
                log.debug(JSON.toJSONString(shuttleProtocol));
            }
        } catch (Exception e) {
            e.printStackTrace();
@@ -269,6 +264,11 @@
            socket.setSoTimeout(60000);
            socket.setKeepAlive(true);
            this.socket = socket;
            if (null == shuttleProtocol) {
                shuttleProtocol = new NyShuttleProtocol();
                shuttleProtocol.setShuttleNo(slave.getId().shortValue());
            }
            shuttleProtocol.setProtocolStatus(ShuttleProtocolStatusType.IDLE);
            log.info(MessageFormat.format("【{0}】四向穿梭车Socket链接成功 ===>> [id:{1}] [ip:{2}] [port:{3}]", DateUtils.convert(new Date()), slave.getId(), slave.getIp(), slave.getPort()));
        } catch (IOException e) {
            OutputQueue.SHUTTLE.offer(MessageFormat.format("【{0}】四向穿梭车Socket链接失败 ===>> [id:{1}] [ip:{2}] [port:{3}]", DateUtils.convert(new Date()), slave.getId(), slave.getIp(), slave.getPort()));