#

Junjie

2025-01-08 97821c4acc241cd65fd4ae890a44201df065c590

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

@@ -1835,58 +1835,59 @@

                //小车所在楼层
                int lev = Utils.getLev(shuttleProtocol.getCurrentLocNo());
//                ShuttleChargeType shuttleCharge = null;
//
//                //搜索小车所在楼层有没有充电桩
//                for (ShuttleChargeType chargeType : ShuttleChargeType.values()) {
//                    if (lev != Utils.getLev(chargeType.locNo)) {
//                        continue;//小车和充电桩不在同一层
//                    }
//
//                    //小车和充电桩在同一层
//                    if (wrkChargeService.selectWorkingOfCharge(chargeType.id) == null) {
//                        shuttleCharge = chargeType;
//                        break;
//                    }
//                }
//
//                if (shuttleCharge == null) {
//                    //同楼层没有找到充电桩，找可用充电桩
//                    //小车同楼层没有充电桩，只要充电桩可用就生成充电任务
//                    for (ShuttleChargeType chargeType : ShuttleChargeType.values()) {
//                        if (wrkChargeService.selectWorkingOfCharge(chargeType.id) == null) {
//                            //判断当前充电桩楼层是否有小车，如有小车，不分配该充电桩
//                            int chargeLev = Utils.getLev(chargeType.locNo);//充电桩楼层
//                            boolean checkLevHasShuttle = Utils.checkLevHasShuttle(chargeLev);//检测楼层是否有穿梭车
//                            if (checkLevHasShuttle) {
//                                //当前充电桩楼层有穿梭车，不分配该充电桩
//                                continue;
//                            }
//
//                            shuttleCharge = chargeType;
//                            break;
//                        }
//                    }
//                }
//
//                if (shuttleCharge == null) {
//                    continue;
//                }
//
//                String chargeLocNo = shuttleCharge.locNo;
//                wrkCharge = new WrkCharge();
//                wrkCharge.setShuttleNo(shuttle.getId());
//                wrkCharge.setCharge(shuttleCharge.id);
//                wrkCharge.setWrkNo(commonService.getChargeWorkNo(4));
//                wrkCharge.setWrkSts(51L);   // 51.准备充电
//                wrkCharge.setIoPri((double) 10);
//                wrkCharge.setLocNo(chargeLocNo);
//                wrkCharge.setMemo("charge");
//                wrkCharge.setAppeTime(new Date());
//                if (!wrkChargeService.insert(wrkCharge)) {
//                    News.error("保存{}号四向穿梭车充电任务失败!!!", shuttle.getId());
//                    continue;
//                }
                ShuttleChargeType shuttleCharge = null;

                //搜索小车所在楼层有没有充电桩
                for (ShuttleChargeType chargeType : ShuttleChargeType.values()) {
                    if (lev != Utils.getLev(chargeType.locNo)) {
                        continue;//小车和充电桩不在同一层
                    }

                    //小车和充电桩在同一层
                    if (wrkMastService.selectChargeWorkingByChargeSta(chargeType.id) == null) {
                        shuttleCharge = chargeType;
                        break;
                    }
                }

                if (shuttleCharge == null) {
                    //同楼层没有找到充电桩，找可用充电桩
                    //小车同楼层没有充电桩，只要充电桩可用就生成充电任务
                    for (ShuttleChargeType chargeType : ShuttleChargeType.values()) {
                        if (wrkMastService.selectChargeWorkingByChargeSta(chargeType.id) == null) {
                            //判断当前充电桩楼层是否有小车，如有小车，不分配该充电桩
                            int chargeLev = Utils.getLev(chargeType.locNo);//充电桩楼层
                            boolean checkLevHasShuttle = Utils.checkLevHasShuttle(chargeLev);//检测楼层是否有穿梭车
                            if (checkLevHasShuttle) {
                                //当前充电桩楼层有穿梭车，不分配该充电桩
                                continue;
                            }

                            shuttleCharge = chargeType;
                            break;
                        }
                    }
                }

                if (shuttleCharge == null) {
                    continue;
                }

                String chargeLocNo = shuttleCharge.locNo;
                wrkMast = new WrkMast();
                wrkMast.setMk(String.valueOf(shuttleCharge.id));
                wrkMast.setWrkNo(commonService.getWorkNo(WrkIoType.SHUTTLE_CHARGE.id));
                wrkMast.setWrkSts(WrkStsType.NEW_CHARGE.sts);
                wrkMast.setIoType(WrkIoType.SHUTTLE_CHARGE.id);//300.充电
                wrkMast.setIoPri((double) 999);
                wrkMast.setLocNo(chargeLocNo);
                wrkMast.setShuttleNo(shuttle.getId());
                wrkMast.setMemo("charge");
                wrkMast.setAppeTime(new Date());
                if (!wrkMastService.insert(wrkMast)) {
                    News.error("保存{}号四向穿梭车充电任务失败!!!", shuttle.getId());
                    continue;
                }

                News.info("保存{}号四向穿梭车充电任务成功!!!", shuttle.getId());
            }
@@ -1895,135 +1896,224 @@
        }
    }

//    /**
//     * 执行四向穿梭车充电任务
//     */
//    public synchronized void executeShuttleCharge() {
//        try {
//            for (ShuttleSlave shuttle : slaveProperties.getShuttle()) {
//                WrkCharge wrkCharge = wrkChargeService.selectWorking(shuttle.getId());
//                if (wrkCharge == null) {
//                    continue;
//                }
//
//                NyShuttleThread shuttleThread = (NyShuttleThread) SlaveConnection.get(SlaveType.Shuttle, wrkCharge.getShuttleNo());
//                if (shuttleThread == null) {
//                    continue;
//                }
//                NyShuttleProtocol shuttleProtocol = shuttleThread.getShuttleProtocol();
//                if (shuttleProtocol == null) {
//                    continue;
//                }
//
//                if (wrkCharge.getWrkSts() == 51) {
//                    if (!shuttleProtocol.isIdleNoCharge()) {
//                        continue;
//                    }
//
//                    if (shuttleProtocol.getSuspendState() == 1) {
//                        continue;//管制中
//                    }
//
//                    if (!shuttleProtocol.getCurrentLocNo().equals(wrkCharge.getLocNo())) {
//                        //小车不在充电桩位置
//                        shuttleDispatchUtils.dispatchShuttle(wrkCharge.getWrkNo(), wrkCharge.getLocNo(), shuttle.getId());//调度小车去充电桩
//                        continue;
//                    }
//
//                    //小车已经在充电桩位置，下发充电命令
//                    NyShuttleHttpCommand chargeCommand = NyHttpUtils.getChargeCommand(shuttle.getId(), wrkCharge.getWrkNo(), true);
//                    ArrayList<NyShuttleHttpCommand> commands = new ArrayList<>();
//                    commands.add(chargeCommand);
//                    //创建分配命令
//                    ShuttleAssignCommand assignCommand = new ShuttleAssignCommand();
//                    assignCommand.setShuttleNo(shuttleProtocol.getShuttleNo());//四向穿梭车号
//                    assignCommand.setTaskNo(wrkCharge.getWrkNo().shortValue());//任务号
//                    assignCommand.setTaskMode(ShuttleTaskModeType.CHARGE.id.shortValue());//出库模式
//                    assignCommand.setSourceLocNo(shuttleProtocol.getCurrentLocNo());//源库位(小车当前位置)
//                    assignCommand.setCommands(commands);//运行命令
//
//                    wrkCharge.setWrkSts(52L);//51.生成充电任务 => 52.小车去充电中
//                    wrkCharge.setModiTime(new Date());
//                    if (wrkChargeMapper.updateById(wrkCharge) > 0) {
//                        //下发任务
//                        MessageQueue.offer(SlaveType.Shuttle, assignCommand.getShuttleNo().intValue(), new Task(3, assignCommand));
//                    }
//                } else if (wrkCharge.getWrkSts() == 52) {
//                    //检测小车是否满电
//
//                    //获取满电阈值
//                    int maxPower = 95;
//                    EntityWrapper<Config> wrapper = new EntityWrapper<>();
//                    wrapper.eq("code", "chargeMaxValue");
//                    Config config = configService.selectOne(wrapper);
//                    if (config != null) {
//                        maxPower = Integer.parseInt(config.getValue());
//                    }
//
//                    if (shuttleProtocol.getPowerPercent() < maxPower) {
//                        continue;
//                    }
//
//                    //***************判断是否满充校准***************
//                    EntityWrapper<Config> wrapper1 = new EntityWrapper<>();
//                    wrapper.eq("code", "shuttleMaxPowerVerify");
//                    Config config1 = configService.selectOne(wrapper1);
//                    if (config1 != null) {
//                        if (config1.getValue().equals("true")) {
//                            if (shuttleProtocol.getVoltage() < 5630) {
//                                continue;//电压不够继续充电
//                            }
//                        }
//                    }
//                    //***************判断是否满充校准***************
//
//                    //小车满电，结束充电任务
//                    NyShuttleHttpCommand chargeCommand = NyHttpUtils.getChargeCommand(shuttle.getId(), wrkCharge.getWrkNo(), false);
//                    ArrayList<NyShuttleHttpCommand> commands = new ArrayList<>();
//                    commands.add(chargeCommand);
//                    //创建分配命令
//                    ShuttleAssignCommand assignCommand = new ShuttleAssignCommand();
//                    assignCommand.setShuttleNo(shuttleProtocol.getShuttleNo());//四向穿梭车号
//                    assignCommand.setTaskNo(wrkCharge.getWrkNo().shortValue());//任务号
//                    assignCommand.setTaskMode(ShuttleTaskModeType.CHARGE.id.shortValue());//出库模式
//                    assignCommand.setSourceLocNo(shuttleProtocol.getCurrentLocNo());//源库位(小车当前位置)
//                    assignCommand.setCommands(commands);//运行命令
//
//                    //下发任务
//                    MessageQueue.offer(SlaveType.Shuttle, assignCommand.getShuttleNo().intValue(), new Task(3, assignCommand));
//                    try {
//                        Thread.sleep(3000);
//                    } catch (Exception e) {
//                        e.printStackTrace();
//                    }
//
//                    wrkCharge.setWrkSts(53L);//52.小车去充电中 => 53.小车充电完成
//                    wrkCharge.setModiTime(new Date());
//                    if (wrkChargeMapper.updateById(wrkCharge) > 0) {
//                        shuttleProtocol.setProtocolStatus(ShuttleProtocolStatusType.IDLE.id);
//                        shuttleProtocol.setTaskNo(0);
//                        shuttleProtocol.setPakMk(false);
//                    }
//                } else if (wrkCharge.getWrkSts() == 53) {
//                    if (shuttleProtocol.getChargState() == 0) {//小车处于未充电状态
//                        boolean result = Utils.searchEmptyGroupToMoveShuttle(Utils.getLev(wrkCharge.getLocNo()), shuttleThread.getSlave().getId(), shuttleThread);
//                        if (!result) {
//                            continue;
//                        }
//
//                        wrkCharge.setWrkSts(60L);//53.小车充电完成 => 60.充电任务完成
//                        wrkCharge.setModiTime(new Date());
//                        if (wrkChargeMapper.updateById(wrkCharge) > 0) {
//
//                        }
//                    }
//                }
//
//            }
//        } catch (Exception e) {
//            e.printStackTrace();
//        }
//    }
    /**
     * 执行四向穿梭车充电任务
     */
    public synchronized void executeShuttleCharge() {
        try {
            //查询小车移库任务
            for (ShuttleSlave shuttle : slaveProperties.getShuttle()) {
                WrkMast wrkMast = wrkMastService.selectChargeWorking(shuttle.getId());
                if(wrkMast == null) {
                    continue;
                }

                boolean result1 = this.executeShuttleChargeStepGoToChargeSta(wrkMast);//小车等待充电桩
                if (!result1) {
                    continue;
                }

                boolean result2 = this.executeShuttleChargeStepArrivalChargeSta(wrkMast);//小车到达充电桩
                if (!result2) {
                    continue;
                }

                boolean result3 = this.executeShuttleChargeStepStartCharge(wrkMast);//小车开始充电
                if (!result3) {
                    continue;
                }

                boolean result4 = this.executeShuttleChargeStepStopCharge(wrkMast);//小车停止充电
                if (!result4) {
                    continue;
                }

                boolean result5 = this.executeShuttleChargeStepLeaveCharge(wrkMast);//小车离开充电桩
                if (!result5) {
                    continue;
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 小车前往充电桩
     */
    private synchronized boolean executeShuttleChargeStepGoToChargeSta(WrkMast wrkMast) {
        if (wrkMast.getWrkSts() == WrkStsType.NEW_CHARGE.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 (shuttleProtocol.getCurrentLocNo().equals(wrkMast.getLocNo())) {
                //小车在充电桩位置
                wrkMast.setWrkSts(WrkStsType.CHARGE_SHUTTLE_RUN_COMPLETE.sts);
                wrkMast.setModiTime(new Date());
                wrkMastService.updateById(wrkMast);
                return false;
            }

            //调度小车去充电桩
            boolean dispatched = shuttleDispatchUtils.dispatchShuttle(wrkMast.getWrkNo(), wrkMast.getLocNo(), wrkMast.getShuttleNo());
            if (!dispatched) {
                return false;
            }

            wrkMast.setWrkSts(WrkStsType.CHARGE_SHUTTLE_RUN.sts);//小车前往充电桩
            wrkMast.setModiTime(new Date());
            wrkMastService.updateById(wrkMast);
            return false;
        }
        return true;
    }

    /**
     * 小车到达充电桩
     */
    private synchronized boolean executeShuttleChargeStepArrivalChargeSta(WrkMast wrkMast) {
        if (wrkMast.getWrkSts() == WrkStsType.CHARGE_SHUTTLE_RUN.sts) {
            ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, wrkMast.getShuttleNo());
            if (shuttleThread == null) {
                return false;
            }
            ShuttleProtocol shuttleProtocol = shuttleThread.getStatus();
            if (shuttleProtocol == null) {
                return false;
            }

            //判断是否存在未完成的移动任务
            WrkMast moveWrk = wrkMastService.selectShuttleHasMoveWorking(wrkMast.getShuttleNo());
            if(moveWrk != null) {
                return false;
            }

            if (!shuttleProtocol.getCurrentLocNo().equals(wrkMast.getLocNo())) {
                return false;
            }

            //小车在充电桩位置
            wrkMast.setWrkSts(WrkStsType.CHARGE_SHUTTLE_RUN_COMPLETE.sts);//小车到达充电桩
            wrkMast.setModiTime(new Date());
            wrkMastService.updateById(wrkMast);

            return false;
        }
        return true;
    }

    //小车开始充电
    private synchronized boolean executeShuttleChargeStepStartCharge(WrkMast wrkMast) {
        if (wrkMast.getWrkSts() == WrkStsType.CHARGE_SHUTTLE_RUN_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;
            }

            //小车已经在充电桩位置，下发充电命令
            ShuttleAssignCommand assignCommand = new ShuttleAssignCommand();
            assignCommand.setShuttleNo(shuttleProtocol.getShuttleNo());//四向穿梭车号
            assignCommand.setTaskNo(wrkMast.getWrkNo());//任务号
            assignCommand.setTaskMode(ShuttleTaskModeType.CHARGE.id);//出库模式
            assignCommand.setSourceLocNo(shuttleProtocol.getCurrentLocNo());//源库位(小车当前位置)

            List<ShuttleCommand> commands = shuttleOperaUtils.shuttleChargeCommand(assignCommand, shuttleThread, true);
            assignCommand.setCommands(commands);//运行命令

            wrkMast.setWrkSts(WrkStsType.CHARGE_SHUTTLE_WORKING.sts);
            wrkMast.setModiTime(new Date());
            if (!wrkMastService.updateById(wrkMast)) {
                return false;
            }

            //下发任务
            shuttleAction.assignWork(shuttleProtocol.getShuttleNo(), assignCommand);
            return false;
        }
        return true;
    }

    //小车停止充电
    private synchronized boolean executeShuttleChargeStepStopCharge(WrkMast wrkMast) {
        if (wrkMast.getWrkSts() == WrkStsType.CHARGE_SHUTTLE_WORKING.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.isChargingCompleted()) {
                return false;
            }

            //小车已经在充电桩位置，下发停止充电命令
            ShuttleAssignCommand assignCommand = new ShuttleAssignCommand();
            assignCommand.setShuttleNo(shuttleProtocol.getShuttleNo());//四向穿梭车号
            assignCommand.setTaskNo(wrkMast.getWrkNo());//任务号
            assignCommand.setTaskMode(ShuttleTaskModeType.CHARGE.id);//出库模式
            assignCommand.setSourceLocNo(shuttleProtocol.getCurrentLocNo());//源库位(小车当前位置)

            List<ShuttleCommand> commands = shuttleOperaUtils.shuttleChargeCommand(assignCommand, shuttleThread, false);
            assignCommand.setCommands(commands);//运行命令

            wrkMast.setWrkSts(WrkStsType.CHARGE_SHUTTLE_COMPLETE.sts);
            wrkMast.setModiTime(new Date());
            if (!wrkMastService.updateById(wrkMast)) {
                return false;
            }

            //下发任务
            shuttleAction.assignWork(shuttleProtocol.getShuttleNo(), assignCommand);
            return false;
        }
        return true;
    }

    //小车离开充电桩
    private synchronized boolean executeShuttleChargeStepLeaveCharge(WrkMast wrkMast) {
        if (wrkMast.getWrkSts() == WrkStsType.CHARGE_SHUTTLE_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;
            }

            ShuttleChargeType chargeType = ShuttleChargeType.get(wrkMast.getMk());
            if(chargeType == null) {
                return false;
            }

            wrkMast.setWrkSts(WrkStsType.CHARGE_SHUTTLE_COMPLETE.sts);
            wrkMast.setModiTime(new Date());
            if (wrkMastService.updateById(wrkMast)) {
                //调度小车去待机位
                boolean dispatched = shuttleDispatchUtils.dispatchShuttle(wrkMast.getWrkNo(), chargeType.waitLocNo, wrkMast.getShuttleNo());
                if (!dispatched) {
                    return false;
                }
                return false;
            }

            return false;
        }
        return true;
    }

    /**
     * 执行小车移库任务