充电逻辑

Junjie

2023-06-20 a3460ef70c67b64cc4bd28feb957df03b19325ad

充电逻辑

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

@@ -1364,10 +1364,8 @@
                            wrkCharge.setWrkSts(53L);//迁移完成
                            shuttleProtocol.setProtocolStatus(ShuttleProtocolStatusType.CHARGING);
                            break;
                        case 56:
                            if (shuttleProtocol.getBatteryPower() == 1000) {
                                wrkCharge.setWrkSts(60L);//充电完成
                            }
                        case 56://小车去充电桩中
                            wrkCharge.setWrkSts(57L);//到达充电桩
                            break;
                        default:
                    }
@@ -2394,109 +2392,243 @@
     * 四向穿梭车电量检测 ===>> 发起充电
     */
    public synchronized void loopShuttleCharge() {
        for (DevpSlave devpSlave : slaveProperties.getDevp()) {
            SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, devpSlave.getId());
            for (ShuttleSlave shuttle : slaveProperties.getShuttle()) {
                //获取四向穿梭车线程
                ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, shuttle.getId());
                ShuttleProtocol shuttleProtocol = shuttleThread.getShuttleProtocol();
                if (shuttleProtocol == null) {
                    continue;
                }

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

                WrkCharge wrkCharge = wrkChargeService.selectWorking(null, WrkChargeType.charge);
                if (wrkCharge != null) {//已有充电任务
                    continue;
                }

                ShuttleChargeType shuttleCharge = null;
                for (ShuttleChargeType chargeType : ShuttleChargeType.values()) {
                    if (wrkChargeService.selectWorkingOfCharge(chargeType.id) == null) {
                        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);   // 21.准备充电
                wrkCharge.setIoPri((double) 10);
                wrkCharge.setLocNo(chargeLocNo);
                wrkCharge.setMemo("charge");
                wrkCharge.setAppeTime(new Date());
                if (!wrkChargeService.insert(wrkCharge)) {
                    News.error("保存{}号四向穿梭车充电任务失败!!!", shuttle.getId());
                    continue;
                }

                shuttleProtocol.setProtocolStatus(ShuttleProtocolStatusType.CHARGING);//充电中
                News.info("保存{}号四向穿梭车充电任务成功!!!", shuttle.getId());
        for (ShuttleSlave shuttle : slaveProperties.getShuttle()) {
            //获取四向穿梭车线程
            ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, shuttle.getId());
            ShuttleProtocol shuttleProtocol = shuttleThread.getShuttleProtocol();
            if (shuttleProtocol == null) {
                continue;
            }

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

            WrkCharge wrkCharge = wrkChargeService.selectWorking(shuttleProtocol.getShuttleNo().intValue(), WrkChargeType.charge);
            if (wrkCharge != null) {//已有充电任务
                continue;
            }

            ShuttleChargeType shuttleCharge = null;
            for (ShuttleChargeType chargeType : ShuttleChargeType.values()) {
                if (wrkChargeService.selectWorkingOfCharge(chargeType.id) == null) {
                    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);   // 21.准备充电
            wrkCharge.setIoPri((double) 10);
            wrkCharge.setLocNo(chargeLocNo);
            wrkCharge.setMemo("charge");
            wrkCharge.setAppeTime(new Date());
            if (!wrkChargeService.insert(wrkCharge)) {
                News.error("保存{}号四向穿梭车充电任务失败!!!", shuttle.getId());
                continue;
            }

            shuttleProtocol.setProtocolStatus(ShuttleProtocolStatusType.CHARGING);//充电中
            News.info("保存{}号四向穿梭车充电任务成功!!!", shuttle.getId());
        }


    }

    /**
     * 执行四向穿梭车充电任务
     */
    public synchronized void executeShuttleCharge() {
        WrkCharge wrkCharge = wrkChargeService.selectWorking(null, WrkChargeType.charge);
        if (wrkCharge == null) {
            return;
        }
        for (ShuttleSlave shuttle : slaveProperties.getShuttle()) {
            WrkCharge wrkCharge = wrkChargeService.selectWorking(null, WrkChargeType.charge);
            if (wrkCharge == null) {
                return;
            }

        ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, wrkCharge.getShuttleNo());
        if (shuttleThread == null) {
            return;
        }
        ShuttleProtocol shuttleProtocol = shuttleThread.getShuttleProtocol();
        if (shuttleProtocol == null) {
            return;
        }
            ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, wrkCharge.getShuttleNo());
            if (shuttleThread == null) {
                return;
            }
            ShuttleProtocol shuttleProtocol = shuttleThread.getShuttleProtocol();
            if (shuttleProtocol == null) {
                return;
            }

        //当前穿梭车库位号
        String currentLocNo = shuttleProtocol.getCurrentLocNo();
        //小车当前层高
        Integer currentLev = currentLocNo == null ? 0 : Utils.getLev(currentLocNo);
        //获取提升机
        LiftThread liftThread = (LiftThread) SlaveConnection.get(SlaveType.Lift, 1);
        if (liftThread == null) {
            return;
        }
        LiftProtocol liftProtocol = liftThread.getLiftProtocol();
        if (liftProtocol == null) {
            return;
        }
        //充电库位号
        String chargeLocNo = wrkCharge.getLocNo();
        //充电库位层高
        Integer chargeLocNoLev = Utils.getLev(chargeLocNo);
            //当前穿梭车库位号
            String currentLocNo = shuttleProtocol.getCurrentLocNo();
            if (currentLocNo == null) {
                return;
            }
            //小车当前层高
            Integer currentLev = Utils.getLev(currentLocNo);
            //获取提升机
            LiftThread liftThread = (LiftThread) SlaveConnection.get(SlaveType.Lift, 1);
            if (liftThread == null) {
                return;
            }
            LiftProtocol liftProtocol = liftThread.getLiftProtocol();
            if (liftProtocol == null) {
                return;
            }
            //充电库位号
            String chargeLocNo = wrkCharge.getLocNo();
            //充电库位层高
            Integer chargeLocNoLev = Utils.getLev(chargeLocNo);

        if (wrkCharge.getWrkSts() == 51) {
            if (currentLev == chargeLocNoLev) {
                //同一层无需经过提升机
            if (wrkCharge.getWrkSts() == 51) {
                if (currentLev == chargeLocNoLev) {
                    //同一层无需经过提升机
                    //直接计算车到充电库位

                    ShuttleAssignCommand assignCommand = new ShuttleAssignCommand();

                    //获取小车到充电库位路径指令
                    List<ShuttleCommand> commands = this.shuttleAssignCommand(currentLocNo, chargeLocNo, NavigationMapType.NONE.id, assignCommand, shuttleThread);
                    if (commands == null) {
                        return;//未找到路径
                    }
                    //进行充电中
                    shuttleProtocol.setProtocolStatus(ShuttleProtocolStatusType.CHARGING);

                    assignCommand.setShuttleNo(shuttleProtocol.getShuttleNo());
                    assignCommand.setTaskMode((short) 9);//充电
                    assignCommand.setTaskNo(wrkCharge.getWrkNo().shortValue());
                    assignCommand.setCharge(true);//充电任务

                    //创建充电指令
                    ShuttleCommand command = shuttleThread.getChargeSwitchCommand((short) 1);//开始充电
                    commands.add(command);

                    //指令集分配
                    assignCommand.setCommands(commands);

                    wrkCharge.setWrkSts(56L);//充电中状态
                    if (wrkChargeMapper.updateById(wrkCharge) > 0) {
                        //下发任务
                        MessageQueue.offer(SlaveType.Shuttle, assignCommand.getShuttleNo().intValue(), new Task(3, assignCommand));
                    }
                }else {
                    //不同层，调度小车到充电桩目标层

                    ShuttleAssignCommand assignCommand = new ShuttleAssignCommand();

                    //获取小车当前楼层的站点号
                    String liftSiteLocNo = Utils.levToOutInStaLocNo(currentLev);

                    //小车移动到提升机口站点，计算路径
                    List<ShuttleCommand> commands = this.shuttleAssignCommand(currentLocNo, liftSiteLocNo, NavigationMapType.NONE.id, assignCommand, shuttleThread);
                    if (commands == null) {
                        return;//未找到路径
                    }

                    //获取当前小车所在楼层的站点信息
                    BasDevp basDevp = basDevpService.queryByLocNo(liftSiteLocNo);
                    if (basDevp == null) {
                        return;//找不到站点信息
                    }
                    Short basDevpQrCode = Short.parseShort(basDevp.getQrCodeValue());//站点二维码

                    //增加移动进提升机命令
                    ShuttleCommand moveCommand = shuttleThread.getMoveCommand(basDevpQrCode, liftProtocol.getBarcode(), 1400, ShuttleRunDirection.TOP.id, basDevpQrCode, 1400, 500);
                    commands.add(moveCommand);

                    //分配目标库位
                    shuttleProtocol.setLocNo(chargeLocNo);
                    assignCommand.setShuttleNo(shuttleProtocol.getShuttleNo());
                    assignCommand.setTaskMode((short) 9);//充电
                    assignCommand.setTaskNo(wrkCharge.getWrkNo().shortValue());
                    assignCommand.setCharge(true);//充电任务
                    //目标库位
                    assignCommand.setLocNo(chargeLocNo);
                    //源库位
                    assignCommand.setSourceLocNo(currentLocNo);
                    assignCommand.setCommands(commands);
                    wrkCharge.setWrkSts(52L);//小车迁移状态
                    if (wrkChargeMapper.updateById(wrkCharge) > 0) {
                        //下发任务
                        MessageQueue.offer(SlaveType.Shuttle, assignCommand.getShuttleNo().intValue(), new Task(3, assignCommand));
                    }
                }

            }else if(wrkCharge.getWrkSts() == 53){
                //小车已经达到提升机内

                //判断提升机是否处于空闲状态
                if (!liftProtocol.isIdle()) {
                    return;
                }

                //判断小车是否在提升机内
                if (shuttleProtocol.getCurrentCode().intValue() != liftProtocol.getBarcode().intValue()) {
                    //小车不在提升机内
                    return;
                }

                //给提升机分配任务
                liftProtocol.setTaskNo(wrkCharge.getWrkNo().shortValue());//设置任务号
                liftProtocol.setShuttleNo(wrkCharge.getShuttleNo().shortValue());//设置四向穿梭车号
                liftProtocol.setProtocolStatus(LiftProtocolStatusType.WORKING);//设置提升机状态为工作中

                //命令list
                ArrayList<LiftCommand> commands = new ArrayList<>();

                //提升机前往目标楼层
                //获取充电库位目标楼层命令
                LiftCommand command1 = liftThread.getLiftUpDownCommand(liftProtocol.getLiftNo(), liftProtocol.getTaskNo(), chargeLocNoLev >= 2 ? chargeLocNoLev + 1 : chargeLocNoLev);
                commands.add(command1);//将命令添加进list

                wrkCharge.setWrkSts(54L);//提升机搬运中
                //所需命令组合完毕，更新数据库，提交到线程去工作
                LiftAssignCommand assignCommand = new LiftAssignCommand();
                assignCommand.setCommands(commands);
                assignCommand.setLiftNo(liftProtocol.getLiftNo());
                assignCommand.setTaskNo(liftProtocol.getTaskNo());
                if (wrkChargeMapper.updateById(wrkCharge) > 0) {
                    //下发任务
                    MessageQueue.offer(SlaveType.Lift, liftProtocol.getLiftNo().intValue(), new Task(3, assignCommand));
                }

            }else if(wrkCharge.getWrkSts() == 55){//55.提升机迁移小车完成
                //直接计算车到充电库位

                ShuttleAssignCommand assignCommand = new ShuttleAssignCommand();

                Short liftLev = liftProtocol.getLev();
                if (liftLev == null) {
                    return;
                }
                //判断提升机楼层是否到达目标楼层
                if (liftLev.intValue() != chargeLocNoLev) {
                    return;//没有到达目标楼层
                }

                //此时车在提升机内部，下达一步指令让车移动到提升机口
                Integer staNo = Utils.levToOutInStaNo(liftLev >= 2 ? liftLev + 1 : liftLev);//站点号
                BasDevp basDevp = basDevpService.selectById(staNo);
                if (basDevp == null) {
                    return;//站点不存在
                }

                //获取小车到充电库位路径指令
                List<ShuttleCommand> commands = this.shuttleAssignCommand(currentLocNo, chargeLocNo, NavigationMapType.NONE.id, assignCommand, shuttleThread);
                if (commands == null) {
                    return;//未找到路径
                }

                short startCode = liftProtocol.getBarcode();//提升机内部二维码
                Short distCode = Short.parseShort(basDevp.getQrCodeValue());//提升机口站点二维码
                Short runDirection = ShuttleRunDirection.BOTTOM.id;//运行方向
                //获取命令
                ShuttleCommand moveCommand = shuttleThread.getMoveCommand(startCode, distCode, 1400, runDirection, startCode, 1400, 500);
                commands.add(0, moveCommand);//将该指令添加到队头

                //进行充电中
                shuttleProtocol.setProtocolStatus(ShuttleProtocolStatusType.CHARGING);

@@ -2517,167 +2649,33 @@
                    //下发任务
                    MessageQueue.offer(SlaveType.Shuttle, assignCommand.getShuttleNo().intValue(), new Task(3, assignCommand));
                }
            }else {
                //不同层，调度小车到充电桩目标层
            }else if (wrkCharge.getWrkSts() == 57) {//57.小车到达充电桩
                //充电中
                //判断小车是否充满电量，满电1000或电压54V以上
                if (shuttleProtocol.getBatteryPower() >= 1000 && shuttleProtocol.getCurrentVoltage() >= 54000) {
                    //充满，断开充电
                    List<ShuttleCommand> commands = new ArrayList<>();
                    ShuttleAssignCommand assignCommand = new ShuttleAssignCommand();
                    assignCommand.setShuttleNo(shuttleProtocol.getShuttleNo());
                    assignCommand.setTaskMode((short) 0);
                    assignCommand.setTaskNo(wrkCharge.getWrkNo().shortValue());
                    assignCommand.setCharge(true);

                ShuttleAssignCommand assignCommand = new ShuttleAssignCommand();
                    //创建充电指令
                    ShuttleCommand command = shuttleThread.getChargeSwitchCommand((short) 2);//断开充电
                    commands.add(command);

                //获取小车当前楼层的站点号
                String liftSiteLocNo = Utils.levToOutInStaLocNo(currentLev);
                    //指令集分配
                    assignCommand.setCommands(commands);

                //小车移动到提升机口站点，计算路径
                List<ShuttleCommand> commands = this.shuttleAssignCommand(currentLocNo, liftSiteLocNo, NavigationMapType.NONE.id, assignCommand, shuttleThread);
                if (commands == null) {
                    return;//未找到路径
                }

                //获取当前小车所在楼层的站点信息
                BasDevp basDevp = basDevpService.queryByLocNo(liftSiteLocNo);
                if (basDevp == null) {
                    return;//找不到站点信息
                }
                Short basDevpQrCode = Short.parseShort(basDevp.getQrCodeValue());//站点二维码

                //增加移动进提升机命令
                ShuttleCommand moveCommand = shuttleThread.getMoveCommand(basDevpQrCode, liftProtocol.getBarcode(), 1400, ShuttleRunDirection.TOP.id, basDevpQrCode, 1400, 500);
                commands.add(moveCommand);

                //分配目标库位
                shuttleProtocol.setLocNo(chargeLocNo);
                assignCommand.setShuttleNo(shuttleProtocol.getShuttleNo());
                assignCommand.setTaskMode((short) 9);//充电
                assignCommand.setTaskNo(wrkCharge.getWrkNo().shortValue());
                assignCommand.setCharge(true);//充电任务
                //目标库位
                assignCommand.setLocNo(chargeLocNo);
                //源库位
                assignCommand.setSourceLocNo(currentLocNo);
                assignCommand.setCommands(commands);
                wrkCharge.setWrkSts(52L);//小车迁移状态
                if (wrkChargeMapper.updateById(wrkCharge) > 0) {
                    shuttleProtocol.setProtocolStatus(ShuttleProtocolStatusType.CHARGING_WAITING);
                    //下发任务
                    MessageQueue.offer(SlaveType.Shuttle, assignCommand.getShuttleNo().intValue(), new Task(3, assignCommand));
                }
            }

        }else if(wrkCharge.getWrkSts() == 53){
            //小车已经达到提升机内

            //判断提升机是否处于空闲状态
            if (!liftProtocol.isIdle()) {
                return;
            }

            //判断小车是否在提升机内
            if (shuttleProtocol.getCurrentCode().intValue() != liftProtocol.getBarcode().intValue()) {
                //小车不在提升机内
                return;
            }

            //给提升机分配任务
            liftProtocol.setTaskNo(wrkCharge.getWrkNo().shortValue());//设置任务号
            liftProtocol.setShuttleNo(wrkCharge.getShuttleNo().shortValue());//设置四向穿梭车号
            liftProtocol.setProtocolStatus(LiftProtocolStatusType.WORKING);//设置提升机状态为工作中

            //命令list
            ArrayList<LiftCommand> commands = new ArrayList<>();

            //提升机前往目标楼层
            //获取充电库位目标楼层命令
            LiftCommand command1 = liftThread.getLiftUpDownCommand(liftProtocol.getLiftNo(), liftProtocol.getTaskNo(), chargeLocNoLev >= 2 ? chargeLocNoLev + 1 : chargeLocNoLev);
            commands.add(command1);//将命令添加进list

            wrkCharge.setWrkSts(54L);//提升机搬运中
            //所需命令组合完毕，更新数据库，提交到线程去工作
            LiftAssignCommand assignCommand = new LiftAssignCommand();
            assignCommand.setCommands(commands);
            assignCommand.setLiftNo(liftProtocol.getLiftNo());
            assignCommand.setTaskNo(liftProtocol.getTaskNo());
            if (wrkChargeMapper.updateById(wrkCharge) > 0) {
                //下发任务
                MessageQueue.offer(SlaveType.Lift, liftProtocol.getLiftNo().intValue(), new Task(3, assignCommand));
            }

        }else if(wrkCharge.getWrkSts() == 55){//55.提升机迁移小车完成
            //直接计算车到充电库位

            ShuttleAssignCommand assignCommand = new ShuttleAssignCommand();

            Short liftLev = liftProtocol.getLev();
            if (liftLev == null) {
                return;
            }
            //判断提升机楼层是否到达目标楼层
            if (liftLev.intValue() != chargeLocNoLev) {
                return;//没有到达目标楼层
            }

            //此时车在提升机内部，下达一步指令让车移动到提升机口
            Integer staNo = Utils.levToOutInStaNo(liftLev >= 2 ? liftLev + 1 : liftLev);//站点号
            BasDevp basDevp = basDevpService.selectById(staNo);
            if (basDevp == null) {
                return;//站点不存在
            }

            //获取小车到充电库位路径指令
            List<ShuttleCommand> commands = this.shuttleAssignCommand(currentLocNo, chargeLocNo, NavigationMapType.NONE.id, assignCommand, shuttleThread);
            if (commands == null) {
                return;//未找到路径
            }

            short startCode = liftProtocol.getBarcode();//提升机内部二维码
            Short distCode = Short.parseShort(basDevp.getQrCodeValue());//提升机口站点二维码
            Short runDirection = ShuttleRunDirection.BOTTOM.id;//运行方向
            //获取命令
            ShuttleCommand moveCommand = shuttleThread.getMoveCommand(startCode, distCode, 1400, runDirection, startCode, 1400, 500);
            commands.add(0, moveCommand);//将该指令添加到队头

            //进行充电中
            shuttleProtocol.setProtocolStatus(ShuttleProtocolStatusType.CHARGING);

            assignCommand.setShuttleNo(shuttleProtocol.getShuttleNo());
            assignCommand.setTaskMode((short) 9);//充电
            assignCommand.setTaskNo(wrkCharge.getWrkNo().shortValue());
            assignCommand.setCharge(true);//充电任务

            //创建充电指令
            ShuttleCommand command = shuttleThread.getChargeSwitchCommand((short) 1);//开始充电
            commands.add(command);

            //指令集分配
            assignCommand.setCommands(commands);

            wrkCharge.setWrkSts(56L);//充电中状态
            if (wrkChargeMapper.updateById(wrkCharge) > 0) {
                //下发任务
                MessageQueue.offer(SlaveType.Shuttle, assignCommand.getShuttleNo().intValue(), new Task(3, assignCommand));
            }
        }else if (wrkCharge.getWrkSts() == 56) {
            //充电中
            //判断小车是否充满电量，满电1000或电压54V以上
            if (shuttleProtocol.getBatteryPower() >= 1000 || shuttleProtocol.getCurrentVoltage() >= 54000) {
                //充满，断开充电
                List<ShuttleCommand> commands = new ArrayList<>();
                ShuttleAssignCommand assignCommand = new ShuttleAssignCommand();
                assignCommand.setShuttleNo(shuttleProtocol.getShuttleNo());
                assignCommand.setTaskMode((short) 0);
                assignCommand.setTaskNo(wrkCharge.getWrkNo().shortValue());
                assignCommand.setCharge(true);

                //创建充电指令
                ShuttleCommand command = shuttleThread.getChargeSwitchCommand((short) 2);//断开充电
                commands.add(command);

                //指令集分配
                assignCommand.setCommands(commands);

                shuttleProtocol.setProtocolStatus(ShuttleProtocolStatusType.CHARGING_WAITING);
                //下发任务
                MessageQueue.offer(SlaveType.Shuttle, assignCommand.getShuttleNo().intValue(), new Task(3, assignCommand));
            }

            if (shuttleProtocol.getProtocolStatus() == ShuttleProtocolStatusType.CHARGING_WAITING.id) {
                shuttleProtocol.setProtocolStatus(ShuttleProtocolStatusType.CHARGING);
                if (shuttleProtocol.getProtocolStatus() == ShuttleProtocolStatusType.CHARGING_WAITING.id) {
                    shuttleProtocol.setProtocolStatus(ShuttleProtocolStatusType.CHARGING);
                }
            }
        }


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

@@ -4,7 +4,7 @@

public enum ShuttleChargeType {

    FIRST(1, "1800102"),
    FIRST(1, "1800101"),
    SECOND(2, "1800103"),
    ;


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

@@ -240,6 +240,7 @@
                && this.pakMk.equals(true)
                && this.errorCodeType.equals(ShuttleErrorCodeType.NORMAL)
                && this.taskNo == 0
                && this.protocolStatus.intValue() == ShuttleProtocolStatusType.IDLE.id
                ;
        if (!res) {
            return res;

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

@@ -923,6 +923,10 @@
            command = commands.get(i);
            for (Short qrCodeValue : qrCodeValues) {
                //目标位置是提升机口，或起点位置是提升机口且目标是去提升机内
                if (command.getDistCodeNum() == null || command.getStartCodeNum() == null) {
                    continue;
                }

                if (qrCodeValue.intValue() == command.getDistCodeNum().intValue() || (qrCodeValue.intValue() == command.getStartCodeNum().intValue() && command.getDistCodeNum().intValue() == liftProtocol.getBarcode().intValue())) {
                    //存在
                    step = i + 1;