MainProcess code reformat. crn and ste code are deleted.

Junjie

2023-05-09 7bb086cb2a921450cc6b6fced68ba0664a51b794

MainProcess code reformat.
crn and ste code are deleted.

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

@@ -544,69 +544,6 @@
    }

    /**
     * 堆垛机站出库到出库站
     */
    public void crnStnToOutStn() {
        for (CrnSlave crnSlave : slaveProperties.getCrn()) {
            // 遍历堆垛机出库站
            for (CrnSlave.CrnStn crnStn : crnSlave.getCrnOutStn()) {
                // 获取堆垛机出库站信息
                DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, crnStn.getDevpPlcId());
                StaProtocol staProtocol = devpThread.getStation().get(crnStn.getStaNo());
                if (staProtocol == null) {
                    continue;
                } else {
                    staProtocol = staProtocol.clone();
                }
                if (staProtocol.isAutoing() && staProtocol.isLoading() && (staProtocol.getWorkNo() == 0 || staProtocol.getStaNo() == null)) {
                    // 查询工作档
                    WrkMast wrkMast = wrkMastMapper.selectPakOutStep16(staProtocol.getSiteId());
                    if (wrkMast == null) {
                        continue;
                    }
                    // 判断工作档条件
                    if (wrkMast.getIoType() < 100 || wrkMast.getStaNo() == null || wrkMast.getSourceStaNo() == null) {
                        continue;
                    }
                    // 判断吊车是否实际已完成，且电脑状态在move中，以备电脑进行更新工作档
                    CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, wrkMast.getCrnNo());
                    CrnProtocol crnProtocol = crnThread.getCrnProtocol();
                    if (crnProtocol.statusType == CrnStatusType.FETCHING || crnProtocol.statusType == CrnStatusType.PUTTING) {
                        // 移动中
                        continue;
                    }
                    //  判断堆垛机状态等待确认
                    if (crnProtocol.modeType == CrnModeType.AUTO && crnProtocol.getTaskNo().equals(wrkMast.getWrkNo().shortValue())
                            && crnProtocol.statusType == CrnStatusType.WAITING
                            && crnProtocol.forkPosType == CrnForkPosType.HOME) {

                        // 命令下发区 --------------------------------------------------------------------------

                        // 下发站点信息
                        staProtocol.setWorkNo(wrkMast.getWrkNo().shortValue());
                        staProtocol.setStaNo(wrkMast.getStaNo().shortValue());
                        if (!MessageQueue.offer(SlaveType.Devp, crnStn.getDevpPlcId(), new Task(2, staProtocol))) {
                            continue;
                        }

                        // 更新工作档状态为 17.出库完成
                        wrkMast.setWrkSts(17L);
                        wrkMast.setCrnEndTime(new Date());
                        if (wrkMastMapper.updateById(wrkMast) != 0) {
                            // 复位堆垛机
                            crnThread.setResetFlag(true);
                        } else {
                            News.error("更新工作档的工作状态为 17.出库完成 失败！！！ [工作号:{}]", wrkMast.getWrkNo());
                        }

                    }

                }
            }
        }
    }

    /**
     * 从redis中重启任务
     */
    public synchronized void restartTaskFromRedis() {
@@ -1431,627 +1368,6 @@
    }

    /**
     * 入出库  ===>>  堆垛机入出库作业下发
     */
    public synchronized void crnIoExecute(){
        for (CrnSlave crn : slaveProperties.getCrn()) {
            // 获取堆垛机信息
            CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, crn.getId());
            CrnProtocol crnProtocol = crnThread.getCrnProtocol();
            if (crnProtocol == null) { continue; }
            BasCrnp basCrnp = basCrnpService.selectById(crn.getId());
            if (basCrnp == null) {
                News.error("{}号堆垛机尚未在数据库进行维护！", crn.getId());
                continue;
            }
            // 只有当堆垛机空闲 并且 无任务时才继续执行
            if (crnProtocol.getStatusType() == CrnStatusType.IDLE && crnProtocol.getTaskNo() == 0 && crnProtocol.getModeType() == CrnModeType.AUTO) {
                // 如果最近一次是入库模式
                if (crnProtocol.getLastIo().equals("I")) {
                    if (basCrnp.getInEnable().equals("Y")) {
                        //  入库
                        if (this.crnStnToLoc(crn, crnProtocol)) {
                        }
                        crnProtocol.setLastIo("O");
                    } else if (basCrnp.getOutEnable().equals("Y")) {
                        //  出库
                        if (this.locToCrnStn(crn, crnProtocol)) {
                        }
                        crnProtocol.setLastIo("I");
                    }
                }
                // 如果最近一次是出库模式
                else if (crnProtocol.getLastIo().equals("O")) {
                    if (basCrnp.getOutEnable().equals("Y")) {
                        //  出库
                        if (this.locToCrnStn(crn, crnProtocol)) {
                        }
                        crnProtocol.setLastIo("I");
                    } else if (basCrnp.getInEnable().equals("Y")) {
                        //  入库
                        if (this.crnStnToLoc(crn, crnProtocol)) {
                        }
                        crnProtocol.setLastIo("O");
                    }
                }
                // 库位移转
//                this.locToLoc(crn, crnProtocol);
                // 演示
//                this.steMoveDemo(crn, crnProtocol);
            }
        }
    }

    /**
     * 入库  ===>>  堆垛机站到库位
     */
    public boolean crnStnToLoc(CrnSlave slave, CrnProtocol crnProtocol){
        for (CrnSlave.CrnStn crnStn : slave.getCrnInStn()) {
            boolean flag = false;
            // 获取堆垛机入库站信息
            DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, crnStn.getDevpPlcId());
            StaProtocol staProtocol = devpThread.getStation().get(crnStn.getStaNo());
            if (staProtocol == null) {
                continue;
            } else {
                staProtocol = staProtocol.clone();
            }
            // 查询站点详细信息
            BasDevp staDetl = basDevpService.selectById(crnStn.getStaNo());
            if (staDetl == null) {
                News.error("入库 ===>> 堆垛机站点在数据库不存在, 站点编号={}", crnStn.getStaNo());
                continue;
            }
            // 获取工作状态为 2,3,4,5,6 的入库工作档
            WrkMast wrkMast = wrkMastMapper.selectPakInStep23456(slave.getId(), staProtocol.getWorkNo().intValue(), crnStn.getStaNo());
            if(null == wrkMast) {
//                News.error("{}站点查询无待入库数据 工作号={}", crnStn.getStaNo(), staProtocol.getWorkNo());
                continue;
            }

            // 同库位组进行校验
            List<String> groupLocNo = Utils.getGroupLocNo(wrkMast.getLocNo());
            if (!Cools.isEmpty(groupLocNo)) {
                if (null != wrkMastMapper.selectPakoutWorkingByGroupLoc(groupLocNo)) {
                    continue;
                }
            }

            if (wrkMast.getWrkSts() < 3) {
                if (staProtocol.isAutoing() && staProtocol.isLoading() && staProtocol.getWorkNo() > 0 && staProtocol.isInEnable()
                        && staDetl.getCanining()!=null && staDetl.getCanining().equals("Y")) {
                    flag = true;
                }
                if (!flag) {
                    continue;
                }
            }
            // 获取库位信息
            LocMast locMast = locMastService.selectById(wrkMast.getLocNo());
            if (locMast == null) {
                News.error("查询库存无数据--库位号{}", wrkMast.getLocNo());
                continue;
            }
            if (!locMast.getLocSts().equals("S") && !locMast.getLocSts().equals("Q")) {
                News.error("入库操作库位状态不符合--状态, 库位号={}，库位状态={}", wrkMast.getLocNo(), locMast.getLocSts());
                continue;
            }

            List<LocMast> locMasts = null;
            boolean sign=false;
            if (locMast.getRow1()>=5){
                locMasts=locMastService.selectList(new EntityWrapper<LocMast>().ge("row1", 5)
                        .eq("bay1",locMast.getBay1()).eq("lev1",locMast.getLev1()));
                for (LocMast locMast1:locMasts){
                    if (locMast1.getRow1()>locMast.getRow1()){
                        if (!locMast1.getLocSts().equals("F") && !locMast1.getLocSts().equals("D")){
                            if (!locMast1.getLocSts().equals("X")){
                                sign=true;
                                break;
                            }
                        }
                    }else if (locMast1.getRow1()<locMast.getRow1()){
                        if (locMast1.getLocSts().equals("F") || locMast1.getLocSts().equals("D")){
                            News.error("当前工作档目标库位所在排前边存在货物！", wrkMast.getWrkNo());
                            sign=true;
                            break;
                        }
                    }
                }
            }else {
                locMasts=locMastService.selectList(new EntityWrapper<LocMast>().le("row1", 4)
                        .eq("bay1",locMast.getBay1()).eq("lev1",locMast.getLev1()));
                for (LocMast locMast1:locMasts){
                    if (locMast1.getRow1()>locMast.getRow1()){
                        if (locMast1.getLocSts().equals("F") || locMast1.getLocSts().equals("D")){
                            News.error("当前工作档目标库位所在排前边存在货物！", wrkMast.getWrkNo());
                            sign=true;
                            break;
                        }
                    }else if (locMast1.getRow1()<locMast.getRow1()){
                        if (!locMast1.getLocSts().equals("F") && !locMast1.getLocSts().equals("D")){
                            if (!locMast1.getLocSts().equals("X")){
                                sign=true;
                                break;
                            }
                        }
                    }
                }
            }
            if (sign){
                continue;
            }

            // 检测是否存在出库任务
            if (null != wrkMastMapper.selectPakout(slave.getId(), null)) {
                News.error("{}入库任务无法作业，因存在出库中任务!", wrkMast.getWrkNo());
                continue;
            }

            // 置顶任务
            if (wrkMast.getIoPri()<8000){
                wrkMast.setIoPri(wrkMast.getIoPri()+9000d);
            }
            wrkMastMapper.updateById(wrkMast);

                // 目标库位 ===>> 最外层库位
            if (locMastService.isOutMost(wrkMast.getLocNo(), true)) {
                // 判断小车是否在最外层库位，如果是则搬走，如果不是，则直接堆垛机入库
                Integer steNo = this.hasCar(wrkMast.getLocNo());
                // 有小车
                if (steNo != null) {
                    // 小车行走到堆垛机待搬移点
                    if (wrkMast.getWrkSts() == 2L && wrkMast.getSteNo() == null) {
                        // 没有其他任务
                        if (null == wrkMastMapper.selectPakin(slave.getId(), steNo)) {
                            this.letCarBeReady(wrkMast, steNo, wrkMast.getLocNo());
                            return true;
                        }
                    }
                    // 小车搬走
                    if (wrkMast.getWrkSts() == 3L) {
                        this.carMoveOut(wrkMast, steNo, crnProtocol);
                        return true;
                    }
                    // 没有小车
                } else {

                    // 当前入库库位组没有小车 堆垛机则去站点取货入库
                    // case 1：从始至终库位组都没有小车，没有迁出小车动作，所以工作状态 = 2
                    // case 2：堆垛机已经搬出小车，有迁出小车动作，所以工作状态 = 6
                    if ((wrkMast.getWrkSts() == 2L && wrkMast.getSteNo() == null) || wrkMast.getWrkSts() == 6L) {

                        // 已经存在吊车执行任务时，则过滤
                        if (wrkMastMapper.selectWorking(slave.getId()) != null) {
                            continue;
                        }

                        // 堆垛机入库 命令下发区 --------------------------------------------------------------------------
                        CrnCommand crnCommand = new CrnCommand();
                        crnCommand.setCrnNo(slave.getId()); // 堆垛机编号
                        crnCommand.setTaskNo(wrkMast.getWrkNo().shortValue()); // 工作号
                        crnCommand.setAckFinish((short) 0);  // 任务完成确认位
                        crnCommand.setTaskMode(CrnTaskModeType.LOC_MOVE); // 任务模式:  库位移转
                        crnCommand.setSourcePosX(crnStn.getRow().shortValue());     // 源库位排
                        crnCommand.setSourcePosY(crnStn.getBay().shortValue());     // 源库位列
                        crnCommand.setSourcePosZ(crnStn.getLev().shortValue());     // 源库位层
                        crnCommand.setDestinationPosX(locMast.getRow1().shortValue());     // 目标库位排
                        crnCommand.setDestinationPosY(locMast.getBay1().shortValue());     // 目标库位列
                        crnCommand.setDestinationPosZ(locMast.getLev1().shortValue());     // 目标库位层
                        if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getCrnNo(), new Task(2, crnCommand))) {
                            News.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
                        } else {
                            // 修改工作档状态  7.吊车入库中
                            Date now = new Date();
                            wrkMast.setWrkSts(7L);
                            wrkMast.setCrnStrTime(now);
                            wrkMast.setModiTime(now);
                            if (wrkMastMapper.updateById(wrkMast) == 0) {
                                News.error("修改工作档状态 {} => 7.吊车入库中 失败！！，工作号={}", wrkMast.getWrkSts$(), wrkMast.getWrkNo());
                            } else {
                                return true;
                            }
                        }
                    }

                }

            // 目标库位 ===>> 非最外层库位
            } else {
                // 判断小车是否在当前组库位，如果是则将穿梭车移至最外层，等待堆垛机放货；如果不是，则堆垛机寻找穿梭车，并放置当前组最外层
                Integer steNo = this.hasCarOfIdle(wrkMast.getLocNo());
                // 有小车
                if (steNo != null) {
                    // 小车行走到待机位
                    if (wrkMast.getWrkSts() == 2L && wrkMast.getSteNo() == null) {
                        // 没有其他任务
                        if (null == wrkMastMapper.selectPakin(slave.getId(), steNo)) {
                            this.letCarBeWaiting(wrkMast, steNo, wrkMast.getLocNo());
                        } else {
                            return true;
                        }
                    }
                    // 堆垛机将货放至小车上 3.小车待搬（小车不用搬运，已经在当前组库位） / 6.小车待入  ===>> 7.吊车入库中
                    if (wrkMast.getWrkSts() == 3L || wrkMast.getWrkSts() == 6L) {
                        // 小车处于空闲
                        SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, steNo);
                        SteProtocol steProtocol = steThread.getSteProtocol();
                        if (steProtocol == null) { continue; }
                        if (steProtocol.isIdle()) {

                            // 已经存在吊车执行任务时，则过滤
                            if (wrkMastMapper.selectWorking(slave.getId()) != null) {
                                continue;
                            }
                            // 堆垛机入库 命令下发区 --------------------------------------------------------------------------
                            CrnCommand crnCommand = new CrnCommand();
                            crnCommand.setCrnNo(slave.getId()); // 堆垛机编号
                            crnCommand.setTaskNo(wrkMast.getWrkNo().shortValue()); // 工作号
                            crnCommand.setAckFinish((short) 0);  // 任务完成确认位
                            crnCommand.setTaskMode(CrnTaskModeType.LOC_MOVE); // 任务模式:  库位移转
                            crnCommand.setSourcePosX(crnStn.getRow().shortValue());     // 源库位排
                            crnCommand.setSourcePosY(crnStn.getBay().shortValue());     // 源库位列
                            crnCommand.setSourcePosZ(crnStn.getLev().shortValue());     // 源库位层
                            crnCommand.setDestinationPosX(Utils.getGroupRow(locMast.getLocNo(), true).shortValue());     // 目标库位排
                            crnCommand.setDestinationPosY(locMast.getBay1().shortValue());     // 目标库位列
                            crnCommand.setDestinationPosZ(locMast.getLev1().shortValue());     // 目标库位层
                            if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getCrnNo(), new Task(2, crnCommand))) {
                                News.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
                            } else {
                                // 修改工作档状态  3.小车待搬 ===>> 7.吊车入库中
                                Date now = new Date();
                                wrkMast.setWrkSts(7L);
                                wrkMast.setCrnStrTime(now);
                                wrkMast.setModiTime(now);
                                if (wrkMastMapper.updateById(wrkMast) == 0) {
                                    News.error("修改工作档状态 3.小车待搬/6.小车待入 => 7.吊车入库中 失败！！，工作号={}", wrkMast.getWrkNo());
                                } else {
                                    return true;
                                }
                            }
                        }
                    }
                // 没有小车
                } else {
                    if (wrkMast.getWrkSts() == 2L && wrkMast.getSteNo() == null) {
                        // 寻找当前堆垛机对应的小车
                        SteThread steThread = queryIdleCar(wrkMast);
                        if (steThread != null) {
                            // 没有其他任务
                            if (null == wrkMastMapper.selectPakin(slave.getId(), steNo)) {
                                // 让小车等待搬运待续
                                this.letCarBeReady(wrkMast, steThread.getSlave().getId(), wrkMast.getLocNo());
                                return true;
                            }
                        }
                    }
                    // 堆垛机搬运小车
                    if (wrkMast.getWrkSts() == 3L) {
                        this.carMoveIn(wrkMast, wrkMast.getSteNo(), crnProtocol);
                        return true;
                    }
                }
            }
        }
        return false;
    }

    /**
     * 出库  ===>>  库位到堆垛机站
     */
    public synchronized boolean locToCrnStn(CrnSlave slave, CrnProtocol crnProtocol){
        for (CrnSlave.CrnStn crnStn : slave.getCrnOutStn()) {
            // 获取工作状态为11（生成出库ID）的出库工作档
            WrkMast wrkMast = wrkMastMapper.selectPakOutStep111215(slave.getId(), crnStn.getStaNo());
            if (wrkMast == null) {
                continue;
            }
            // 工作档状态判断
            if (wrkMast.getIoType() < 100 || wrkMast.getSourceStaNo() == null){
                News.error("查询工作档数据不符合条件--入出类型/站点, 工作号={}，源库位={}，入出类型={}", wrkMast.getWrkNo(), wrkMast.getSourceLocNo(), wrkMast.getIoType());
                continue;
            }
            // 获取源库位信息
            LocMast sourceSta = locMastService.selectById(wrkMast.getSourceLocNo());
            if (!sourceSta.getLocSts().equals("R") &&!sourceSta.getLocSts().equals("P")) {
                News.error("出库操作库位状态不符合--状态, 库位号={}，库位状态={}", wrkMast.getLocNo(), sourceSta.getLocSts());
                continue;
            }
            List<LocMast> locMasts = null;
            boolean sign=false;
            if (sourceSta.getRow1()>=5){
                locMasts=locMastService.selectList(new EntityWrapper<LocMast>().ge("row1", 5)
                        .eq("bay1",sourceSta.getBay1()).eq("lev1",sourceSta.getLev1()));
                for (LocMast locMast1:locMasts){
                    if (locMast1.getRow1()<sourceSta.getRow1()){
                        if (!locMast1.getLocSts().equals("O")){
                            News.error("当前工作档源库位所在排前边存在货物！", wrkMast.getWrkNo());
                            sign=true;
                            break;
                        }
                    }
                }
            }else {
                locMasts=locMastService.selectList(new EntityWrapper<LocMast>().le("row1", 4)
                        .eq("bay1",sourceSta.getBay1()).eq("lev1",sourceSta.getLev1()));
                for (LocMast locMast1:locMasts){
                    if (locMast1.getRow1()>sourceSta.getRow1()){
                        if (!locMast1.getLocSts().equals("O")){
                            News.error("当前工作档目标库位所在排前边存在货物！", wrkMast.getWrkNo());
                            sign=true;
                            break;
                        }
                    }
                }
            }
            if (sign){
                continue;
            }

            // 同库位组进行校验
            List<String> groupLocNo = Utils.getGroupLocNo(wrkMast.getSourceLocNo());
            if (!Cools.isEmpty(groupLocNo)) {
                if (null != wrkMastMapper.selectPakinWorkingByGroupLoc(groupLocNo)) {
                    continue;
                }
            }

            // 判断是否有同库位组的出库任务，如果有，则暂停
            List<String> outsideLoc = Utils.getGroupOutsideLoc(wrkMast.getSourceLocNo());
            if (!Cools.isEmpty(outsideLoc)) {
                if (!Cools.isEmpty(wrkMastMapper.selectWorkingOfPakOutBySource(outsideLoc))) {
//                    News.warn("{}工作档出库失败，原因：外层库位{}正在执行出库任务！", wrkMast.getWrkNo(), JSON.toJSONString(outsideLoc));
                    continue;
                }
            }

            // 获取堆垛机出库站信息
            DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, crnStn.getDevpPlcId());
            StaProtocol staProtocol = devpThread.getStation().get(crnStn.getStaNo());
            if (staProtocol == null) {
                continue;
            } else {
                staProtocol = staProtocol.clone();
            }
            // 查询站点详细信息
            BasDevp staDetl = basDevpService.selectById(crnStn.getStaNo());
            if (staDetl == null) {
                News.error("出库 ===>> 堆垛机站点在数据库不存在, 站点编号={}", crnStn.getStaNo());
                continue;
            }
            // 判断堆垛机出库站状态
            if (staProtocol.isAutoing() && !staProtocol.isLoading() && staDetl.getCanouting() !=null && staDetl.getCanouting().equals("Y")
                    && staProtocol.getWorkNo() == 0 && staProtocol.isOutEnable()) {
                // 命令下发区 --------------------------------------------------------------------------

                // 堆垛机控制过滤
                if (!crnProtocol.getStatusType().equals(CrnStatusType.IDLE) || crnProtocol.getTaskNo() != 0) {
                    continue;
                }

                // 过滤
                if (null != wrkMastMapper.selectPakin(slave.getId(), null)) {
                    News.error("{}出库任务无法作业，因存在入库中任务!", wrkMast.getWrkNo());
                    continue;
                }

                // 置顶任务
                if (wrkMast.getIoPri()<8000){
                    wrkMast.setIoPri(wrkMast.getIoPri()+8999d);
                }
                wrkMastMapper.updateById(wrkMast);

                // 最外层库位，直接堆垛机出库
                if (locMastService.isOutMost(wrkMast.getSourceLocNo(), false)) {
                    // 已经存在吊车执行任务时，则过滤
                    if (wrkMastMapper.selectWorking(slave.getId()) != null) {
                        continue;
                    }

                    // 堆垛机出库 命令下发区 --------------------------------------------------------------------------
                    CrnCommand crnCommand = new CrnCommand();
                    crnCommand.setCrnNo(slave.getId()); // 堆垛机编号
                    crnCommand.setTaskNo(wrkMast.getWrkNo().shortValue()); // 工作号
                    crnCommand.setAckFinish((short) 0);  // 任务完成确认位
                    crnCommand.setTaskMode(CrnTaskModeType.LOC_MOVE); // 任务模式:  库位移转
                    crnCommand.setSourcePosX(sourceSta.getRow1().shortValue());     // 源库位排
                    crnCommand.setSourcePosY(sourceSta.getBay1().shortValue());     // 源库位列
                    crnCommand.setSourcePosZ(sourceSta.getLev1().shortValue());     // 源库位层
                    crnCommand.setDestinationPosX(crnStn.getRow().shortValue());     // 目标库位排
                    crnCommand.setDestinationPosY(crnStn.getBay().shortValue());     // 目标库位列
                    crnCommand.setDestinationPosZ(crnStn.getLev().shortValue());     // 目标库位层
                    if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getCrnNo(), new Task(2, crnCommand))) {
                        News.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
                    } else {
                        // 修改工作档状态 11.生成出库ID => 16.吊车出库中
                        Date now = new Date();
                        wrkMast.setWrkSts(16L);
                        wrkMast.setCrnStrTime(now);
                        wrkMast.setModiTime(now);
                        if (wrkMastMapper.updateById(wrkMast) == 0) {
                            News.error("修改工作档状态 11.生成出库ID => 16.吊车出库中 失败！！，工作号={}", wrkMast.getWrkNo());
                        } else {
                            return true;
                        }
                    }
                    // 不是最外层库位，需要使用穿梭车搬运后，再堆垛机出库
                } else {
                    // 当前组库位是否有穿梭车
                    Integer steNo = this.hasCarOfIdle(wrkMast.getSourceLocNo());
                    // 有小车
                    if (steNo != null) {
                        if (wrkMast.getWrkSts() == 11L && wrkMast.getSteNo() == null) {

                            // 给穿梭车下发命令 让其将货物挪至堆垛机搬运点
                            SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, steNo);
                            SteProtocol steProtocol = steThread.getSteProtocol();
                            if (steProtocol == null) { continue; }
                            if (steProtocol.isIdle()) {

                                // 命令下发区 --------------------------------------------------------------------------
                                SteCommand steCommand = new SteCommand();
                                steCommand.setSteNo(steNo); // 穿梭车编号
                                steCommand.setTaskNo(wrkMast.getWrkNo()); // 工作号
                                steCommand.setTaskMode(SteTaskModeType.findOutByLoc(wrkMast.getSourceLocNo())); // 任务模式:  去近点 等待堆垛机叉取

                                steCommand.setRow(Utils.getGroupRow(steProtocol.getRow().intValue(), false).shortValue());
                                steCommand.setBay(steProtocol.getBay());
                                steCommand.setLev(steProtocol.getLev());

                                if (!MessageQueue.offer(SlaveType.Ste, steNo, new Task(2, steCommand))) {
                                    News.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", steNo, JSON.toJSON(steCommand));
                                } else {
                                    // 修改工作档状态 11.生成出库ID => 14.小车搬出库
                                    Date now = new Date();
                                    wrkMast.setWrkSts(14L);
                                    wrkMast.setSteNo(steNo);
                                    wrkMast.setCrnStrTime(now);
                                    wrkMast.setModiTime(now);
                                    LocMast locMast = locMastService.selectById(wrkMast.getSourceLocNo());
                                    Integer outCrnNo = locMastService.getOutCrnNo(locMast);
                                    wrkMast.setCrnNo(outCrnNo);
                                    if (wrkMastMapper.updateById(wrkMast) == 0) {
                                        News.error("修改工作档状态 11.生成出库ID => 14.小车搬出库 失败！！，工作号={}", wrkMast.getWrkNo());
                                    } else {
                                        return true;
                                    }
                                }
                            }
                        }
                        if (wrkMast.getWrkSts() == 15L) {
                            // 已经存在吊车执行任务时，则过滤
                            if (wrkMastMapper.selectWorking(slave.getId()) != null) {
                                continue;
                            }

                            // 堆垛机出库 命令下发区 --------------------------------------------------------------------------
                            CrnCommand crnCommand = new CrnCommand();
                            crnCommand.setCrnNo(slave.getId()); // 堆垛机编号
                            crnCommand.setTaskNo(wrkMast.getWrkNo().shortValue()); // 工作号
                            crnCommand.setAckFinish((short) 0);  // 任务完成确认位
                            crnCommand.setTaskMode(CrnTaskModeType.LOC_MOVE); // 任务模式:  库位移转
                            crnCommand.setSourcePosX(Utils.getGroupRow(sourceSta.getRow1(), false).shortValue());     // 源库位排
                            crnCommand.setSourcePosY(sourceSta.getBay1().shortValue());     // 源库位列
                            crnCommand.setSourcePosZ(sourceSta.getLev1().shortValue());     // 源库位层
                            crnCommand.setDestinationPosX(crnStn.getRow().shortValue());     // 目标库位排
                            crnCommand.setDestinationPosY(crnStn.getBay().shortValue());     // 目标库位列
                            crnCommand.setDestinationPosZ(crnStn.getLev().shortValue());     // 目标库位层
                            if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getCrnNo(), new Task(2, crnCommand))) {
                                News.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
                            } else {
                                // 修改工作档状态 15.等待吊车 => 16.吊车出库中
                                Date now = new Date();
                                wrkMast.setWrkSts(16L);
                                wrkMast.setCrnStrTime(now);
                                wrkMast.setModiTime(now);
                                if (wrkMastMapper.updateById(wrkMast) == 0) {
                                    News.error("修改工作档状态 15.等待吊车 => 16.吊车出库中 失败！！，工作号={}", wrkMast.getWrkNo());
                                } else {
                                    return true;
                                }
                            }
                        }

                        // 没有小车
                    } else {
                        if (wrkMast.getWrkSts() == 11L && wrkMast.getSteNo() == null) {
                            // 寻找最近的小车
                            SteThread steThread = queryIdleCar(wrkMast);
                            if (steThread != null) {
                                // 没有其他任务
                                if (null == wrkMastMapper.selectPakout(slave.getId(), steNo)) {
                                    // 让小车等待搬运待续
                                    this.letCarBeReady(wrkMast, steThread.getSlave().getId(), wrkMast.getSourceLocNo());
                                    return true;
                                }
                            }
                        }
                        // 堆垛机搬运小车
                        if (wrkMast.getWrkSts() == 12L) {
                            this.carMoveIn(wrkMast, wrkMast.getSteNo(), crnProtocol);
                            return true;
                        }
                    }
                }
            }
        }
        return false;
    }

    /**
     * 库位移转
     */
    @Deprecated
    public void locToLoc(CrnSlave slave, CrnProtocol crnProtocol){
        // 获取工作档信息
        WrkMast wrkMast = wrkMastMapper.selectLocMove(slave.getId());
        if (null == wrkMast) {
            return;
        }
        // 获取源库位信息
        LocMast sourceLoc = locMastService.selectById(wrkMast.getSourceLocNo());
        if (null == sourceLoc) {
            News.error("工作档库位移转失败，原因：检索源库位失败！工作号={}，源库位={}", wrkMast.getWrkNo(), wrkMast.getSourceLocNo());
            return;
        }
        // 源库位  库位状态判断
        if (!sourceLoc.getLocSts().equals("R") && !sourceLoc.getLocSts().equals("S")) {
            return;
        }
        // 获取目标库位信息
        LocMast loc = locMastService.selectById(wrkMast.getLocNo());
        if (null == loc) {
            News.error("工作档库位移转失败，原因：检索目标库位失败！工作号={}，源库位={}", wrkMast.getWrkNo(), wrkMast.getLocNo());
            return;
        }
        // 获取堆垛机信息 并 判断是否可入出
        BasCrnp basCrnp = basCrnpService.selectById(slave.getId());
        if (!basCrnp.getInEnable().equals("Y") && !basCrnp.getOutEnable().equals("Y")) {
            return;
        }

        // 堆垛机控制过滤
        if (!crnProtocol.getStatusType().equals(CrnStatusType.IDLE) || crnProtocol.getTaskNo() != 0) {
            return;
        }

        // 已经存在吊车执行任务时，则过滤
        if (wrkMastMapper.selectWorking(slave.getId()) != null) {
            return;
        }

        // 置顶任务
        wrkMast.setIoPri((double) 9999);
        wrkMastMapper.updateById(wrkMast);

        // 命令下发区 --------------------------------------------------------------------------
        CrnCommand crnCommand = new CrnCommand();
        crnCommand.setCrnNo(slave.getId()); // 堆垛机编号
        crnCommand.setTaskNo(wrkMast.getWrkNo().shortValue()); // 工作号
        crnCommand.setAckFinish((short) 0);  // 任务完成确认位
        crnCommand.setTaskMode(CrnTaskModeType.LOC_MOVE); // 任务模式:  库位移转
        crnCommand.setSourcePosX(sourceLoc.getRow1().shortValue());     // 源库位排
        crnCommand.setSourcePosY(sourceLoc.getBay1().shortValue());     // 源库位列
        crnCommand.setSourcePosZ(sourceLoc.getLev1().shortValue());     // 源库位层
        crnCommand.setDestinationPosX(loc.getRow1().shortValue());     // 目标库位排
        crnCommand.setDestinationPosY(loc.getBay1().shortValue());     // 目标库位列
        crnCommand.setDestinationPosZ(loc.getLev1().shortValue());     // 目标库位层
        if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getCrnNo(), new Task(2, crnCommand))) {
            News.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
        } else {
            // 修改工作档状态 11.生成出库ID => 16.吊车出库中
            Date now = new Date();
            wrkMast.setWrkSts(16L);
            wrkMast.setCrnStrTime(now);
            wrkMast.setModiTime(now);
            if (wrkMastMapper.updateById(wrkMast) == 0) {
                News.error("【库位移转】 修改工作档状态 11.生成出库ID => 16.吊车出库中 失败！！，工作号={}", wrkMast.getWrkNo());
            }
        }

    }

    /**
     * 当前库位组是否存在空闲小车
     */
    public Integer hasCar(String locNo) {
@@ -2334,584 +1650,11 @@
    }

    /**
     * 入出库  ===>>  堆垛机搬入小车
     */
    public void carMoveIn(WrkMast wrkMast, Integer steNo, CrnProtocol crnProtocol) {
        // 获取堆垛机信息
        SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, steNo);
        SteProtocol steProtocol = steThread.getSteProtocol();
        if (steProtocol == null) { return; }
        if (steProtocol.isIdle()) {
            // 堆垛机空闲
            if (crnProtocol.getStatusType().equals(CrnStatusType.IDLE) && crnProtocol.getTaskNo() == 0) {
                LocMast locMast;
                // 入库搬
                if (wrkMast.getWrkSts() <= 10) {

                    // 判断被移库位是否存在其他小车
                    Integer otherSte = existOtherSte(wrkMast.getLocNo(), steNo);
                    if (otherSte != null) {
                        News.warn("{}号小车移入{}库位组失败，原因：存在{}号穿梭车！", steNo, wrkMast.getLocNo(), otherSte);
                        return;
                    }

                    locMast = locMastService.selectById(wrkMast.getLocNo());
                    // 堆垛机命令下发区 --------------------------------------------------------------------------
                    CrnCommand crnCommand = new CrnCommand();
                    crnCommand.setCrnNo(crnProtocol.getCrnNo()); // 堆垛机编号
                    crnCommand.setTaskNo(wrkMast.getWrkNo().shortValue()); // 工作号
                    crnCommand.setAckFinish((short) 0);  // 任务完成确认位
                    crnCommand.setTaskMode(CrnTaskModeType.STE_MOVE); // 任务模式:  库位移转
                    crnCommand.setSourcePosX(Utils.getGroupRow(steProtocol.getRow().intValue(), true).shortValue());     // 源库位排
                    crnCommand.setSourcePosY(steProtocol.getBay());     // 源库位列
                    crnCommand.setSourcePosZ(steProtocol.getLev());     // 源库位层
                    crnCommand.setDestinationPosX(Utils.getGroupRow(locMast.getLocNo(), true).shortValue());     // 目标库位排
                    crnCommand.setDestinationPosY(locMast.getBay1().shortValue());     // 目标库位列
                    crnCommand.setDestinationPosZ(locMast.getLev1().shortValue());     // 目标库位层
                    if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getCrnNo(), new Task(2, crnCommand))) {
                        News.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
                    } else {
                        // 修改穿梭车运行中排列层
                        steThread.modifyPos(Utils.getGroupRow(locMast.getLocNo(), true), locMast.getBay1(), locMast.getLev1());
                        // 修改工作档状态 3.小车待搬 => 4.迁入小车
                        Date now = new Date();
                        wrkMast.setWrkSts(4L);
                        wrkMast.setCrnStrTime(now);
                        wrkMast.setModiTime(now);
                        if (wrkMastMapper.updateById(wrkMast) == 0) {
                            News.error("修改工作档状态 3.小车待搬 => 4.迁入小车 失败！！，工作号={}", wrkMast.getWrkNo());
                        }
                    }
                // 出库搬
                } else {
                    // 判断被移库位是否存在其他小车
                    Integer otherSte = existOtherSte(wrkMast.getSourceLocNo(), steNo);
                    if (otherSte != null) {
                        News.warn("{}号小车移入{}库位组失败，原因：存在{}号穿梭车！", steNo, wrkMast.getSourceLocNo(), otherSte);
                        return;
                    }

                    locMast = locMastService.selectById(wrkMast.getSourceLocNo());
                    // 堆垛机命令下发区 --------------------------------------------------------------------------
                    CrnCommand crnCommand = new CrnCommand();
                    crnCommand.setCrnNo(crnProtocol.getCrnNo()); // 堆垛机编号
                    crnCommand.setTaskNo(wrkMast.getWrkNo().shortValue()); // 工作号
                    crnCommand.setAckFinish((short) 0);  // 任务完成确认位
                    crnCommand.setTaskMode(CrnTaskModeType.STE_MOVE); // 任务模式:  库位移转
                    crnCommand.setSourcePosX(Utils.getGroupRow(steProtocol.getRow().intValue(), true).shortValue());     // 源库位排
                    crnCommand.setSourcePosY(steProtocol.getBay());     // 源库位列
                    crnCommand.setSourcePosZ(steProtocol.getLev());     // 源库位层
                    crnCommand.setDestinationPosX(Utils.getGroupRow(locMast.getLocNo(), true).shortValue());     // 目标库位排
                    crnCommand.setDestinationPosY(locMast.getBay1().shortValue());     // 目标库位列
                    crnCommand.setDestinationPosZ(locMast.getLev1().shortValue());     // 目标库位层
                    if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getCrnNo(), new Task(2, crnCommand))) {
                        News.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
                    } else {
                        // 修改穿梭车运行中排列层
                        steThread.modifyPos(Utils.getGroupRow(locMast.getLocNo(), true), locMast.getBay1(), locMast.getLev1());
                        // 修改工作档状态 12.小车待搬 => 13.迁入小车
                        Date now = new Date();
                        wrkMast.setWrkSts(13L);
                        wrkMast.setCrnStrTime(now);
                        wrkMast.setModiTime(now);
                        if (wrkMastMapper.updateById(wrkMast) == 0) {
                            News.error("修改工作档状态 12.小车待搬 => 13.迁入小车 失败！！，工作号={}", wrkMast.getWrkNo());
                        }
                    }
                }
            }

        }
    }

    /**
     * 入库  ===>>  堆垛机搬出小车
     */
    public void carMoveOut(WrkMast wrkMast, Integer steNo, CrnProtocol crnProtocol) {
        // 获取穿梭车信息
        SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, steNo);
        SteProtocol steProtocol = steThread.getSteProtocol();
        if (steProtocol == null) { return; }
        // 穿梭车空闲
        if (steProtocol.isIdle()) {
            // 堆垛机空闲
            if (crnProtocol.getStatusType().equals(CrnStatusType.IDLE) && crnProtocol.getTaskNo() == 0) {

                BasSte basSte = basSteService.selectById(steNo);
                if (basSte == null) {
                    News.error("{}号穿梭车在数据库不存在！！！", steNo);
                    return;
                }

                String idleLocNo = basSte.getIdleLoc();

                // 判断被移库位是否存在其他小车
                Integer otherSte = existOtherSte(idleLocNo, steNo);
                if (otherSte != null) {
                    News.warn("{}号小车移入{}库位组失败，原因：存在{}号穿梭车！", steNo, idleLocNo, otherSte);
                    return;
                }

                // 堆垛机命令下发区 --------------------------------------------------------------------------
                CrnCommand crnCommand = new CrnCommand();
                crnCommand.setCrnNo(crnProtocol.getCrnNo()); // 堆垛机编号
                crnCommand.setTaskNo(wrkMast.getWrkNo().shortValue()); // 工作号
                crnCommand.setAckFinish((short) 0);  // 任务完成确认位
                crnCommand.setTaskMode(CrnTaskModeType.STE_MOVE); // 任务模式:  库位移转
                crnCommand.setSourcePosX(Utils.getGroupRow(steProtocol.getRow().intValue(), true).shortValue());     // 源库位排
                crnCommand.setSourcePosY(steProtocol.getBay());     // 源库位列
                crnCommand.setSourcePosZ(steProtocol.getLev());     // 源库位层
                crnCommand.setDestinationPosX(Utils.getGroupRow(idleLocNo, true).shortValue());     // 目标库位排
                crnCommand.setDestinationPosY((short) Utils.getBay(idleLocNo));     // 目标库位列
                crnCommand.setDestinationPosZ((short) Utils.getLev(idleLocNo));     // 目标库位层
                if (!MessageQueue.offer(SlaveType.Crn, wrkMast.getCrnNo(), new Task(2, crnCommand))) {
                    News.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkMast.getCrnNo(), JSON.toJSON(crnCommand));
                } else {
                    // 修改穿梭车运行中排列层
                    steThread.modifyPos(Utils.getGroupRow(idleLocNo, true), Utils.getBay(idleLocNo), Utils.getLev(idleLocNo));
                    // 修改工作档状态 3.小车待搬 => 5.迁出小车
                    Date now = new Date();
                    wrkMast.setWrkSts(5L);
                    wrkMast.setCrnStrTime(now);
                    wrkMast.setModiTime(now);
                    if (wrkMastMapper.updateById(wrkMast) == 0) {
                        News.error("修改工作档状态 3.小车待搬 => 5.迁出小车 失败！！，工作号={}", wrkMast.getWrkNo());
                    }
                }
            }
        }
    }


    /**
     * 执行对工作档的完成操作
     */
    @Transactional
    public void storeFinished() {
        for (CrnSlave crn : slaveProperties.getCrn()) {
            // 获取堆垛机信息
            CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, crn.getId());
            CrnProtocol crnProtocol = crnThread.getCrnProtocol();
            if (crnProtocol == null) { continue; }
            //  状态：等待确认 并且  任务完成位 = 1
            if (crnProtocol.statusType == CrnStatusType.WAITING && crnProtocol.getTaskNo() != 0) {
                // 获取入库待确认工作档
                WrkMast wrkMast = wrkMastMapper.selectCrnWaiting(crnProtocol.getTaskNo().intValue());
                if (wrkMast == null) {

                    // 充电任务
                    WrkCharge wrkCharge = wrkChargeService.selectById(crnProtocol.getTaskNo());
                    if (wrkCharge == null) {
                        News.error("堆垛机处于等待确认且任务完成状态，但未找到工作档。堆垛机号={}，工作号={}", crn.getId(), crnProtocol.getTaskNo());
                        wrkMast = wrkMastMapper.selectCrnWaiting2(crnProtocol.getTaskNo().intValue());
                        if (wrkMast.getIoType() != 11) {
                            // 修改成功后复位堆垛机
                            if (wrkMastMapper.updateById(wrkMast) > 0) {
                                // 堆垛机复位
                                crnThread.setResetFlag(true);
                                News.error("堆垛机处于等待确认且任务完成状态,复位，但未找到工作档。堆垛机号={}，工作号={}", crn.getId(), crnProtocol.getTaskNo());
                            } else {
                                News.error("堆垛机处于等待确认且任务完成状态,复位失败，但未找到工作档。堆垛机号={}，工作号={}", crn.getId(), crnProtocol.getTaskNo());
                            }
                        }
                        continue;
                    } else {
                        // 小车搬至指定库位完成
                        if (wrkCharge.getWrkSts() == 23) {
                            // 23.吊车搬运 ===>> 24.小车到达
                            wrkCharge.setWrkSts(24L);
                            if (!wrkChargeService.updateById(wrkCharge)) {
                                News.error("修改充电任务状态 23.吊车搬运 ===>> 24.小车到达 失败！！，工作号={}", wrkCharge.getWrkNo());
                            } else {
                                // 堆垛机复位
                                crnThread.setResetFlag(true);
                                // 穿梭车重新定位排列层
                                SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, wrkCharge.getSteNo());
                                if (!steThread.confirmPos()) {
                                    News.error("{}号穿梭车重新定位失败！作业充电任务号：{}", wrkCharge.getSteNo(), wrkCharge.getWrkNo());
                                }
                            }
                        } else if (wrkCharge.getWrkSts() == 27) {
                            // 堆垛机复位
                            crnThread.setResetFlag(true);
                            // 穿梭车重新定位排列层
                            SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, wrkCharge.getSteNo());
                            if (steThread.confirmPos()) {
                                // 27.放至充电位 ===>> 28.充电就绪
                                wrkCharge.setWrkSts(28L);
                                if (!wrkChargeService.updateById(wrkCharge)) {
                                    News.error("修改充电任务状态 27.放至充电位 ===>> 28.充电就绪 失败！！，工作号={}", wrkCharge.getWrkNo());
                                }
                            } else {
                                News.error("{}号穿梭车重新定位失败！作业充电任务号：{}", wrkCharge.getSteNo(), wrkCharge.getWrkNo());
                            }
                        } else if (wrkCharge.getWrkSts() == 34) {
                            // 34.吊车搬运 ===>> 35.小车就绪
                            wrkCharge.setWrkSts(35L);
                            if (!wrkChargeService.updateById(wrkCharge)) {
                                News.error("修改充电任务状态 34.吊车搬运 ===>> 35.小车就绪 失败！！，工作号={}", wrkCharge.getWrkNo());
                            } else {
                                // 堆垛机复位
                                crnThread.setResetFlag(true);
                                // 穿梭车重新定位排列层
                                SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, wrkCharge.getSteNo());
                                if (!steThread.confirmPos()) {
                                    News.error("{}号穿梭车重新定位失败！作业充电任务号：{}", wrkCharge.getSteNo(), wrkCharge.getWrkNo());
                                }
                            }
                        } else if (wrkCharge.getWrkSts() == 42) {
                            // 42.吊车搬运 ===>> 43.小车到达
                            wrkCharge.setWrkSts(43L);
                            if (!wrkChargeService.updateById(wrkCharge)) {
                                News.error("修改复位任务状态 42.吊车搬运 ===>> 43.小车到达 失败！！，工作号={}", wrkCharge.getWrkNo());
                            } else {
                                // 堆垛机复位
                                crnThread.setResetFlag(true);
                                // 穿梭车重新定位排列层
                                SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, wrkCharge.getSteNo());
                                if (!steThread.confirmPos()) {
                                    News.error("{}号穿梭车重新定位失败！作业复位任务号：{}", wrkCharge.getSteNo(), wrkCharge.getWrkNo());
                                }
                            }
                        } else if (wrkCharge.getWrkSts() == 46) {
                            // 46.放至待机位 ===>> 47.复位成功
                            wrkCharge.setWrkSts(47L);
                            if (!wrkChargeService.updateById(wrkCharge)) {
                                News.error("修改复位任务状态 46.放至待机位 ===>> 47.复位成功 失败！！，工作号={}", wrkCharge.getWrkNo());
                            } else {
                                // 堆垛机复位
                                crnThread.setResetFlag(true);
                                // 穿梭车重新定位排列层
                                SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, wrkCharge.getSteNo());
                                if (!steThread.confirmPos()) {
                                    News.error("{}号穿梭车重新定位失败！作业复位任务号：{}", wrkCharge.getSteNo(), wrkCharge.getWrkNo());
                                }
                            }
                        }
                    }

                }
                if (wrkMast == null) { continue; }
                if (wrkMast.getIoType() != 11) {
                    // 入库 ==>> 货物搬入库
                    if (wrkMast.getWrkSts() == 7){
                        // 判断是否需要小车入库
                        if (locMastService.isOutMost(wrkMast.getLocNo(), true)) {
                            // ==> 9.入库完成
                            wrkMast.setWrkSts(9L);
                            Date now = new Date();
                            wrkMast.setCrnEndTime(now);
                            wrkMast.setModiTime(now);
                            // 修改成功后复位堆垛机
                            if (wrkMastMapper.updateById(wrkMast) > 0) {
                                // 堆垛机复位
                                crnThread.setResetFlag(true);
                            } else {
                                News.error("修改工作档状态 7.吊车入库中 => 9.入库完成 失败！！，工作号={}", wrkMast.getWrkNo());
                            }
                        } else {
                            // 给穿梭车下发命令
                            Integer steNo = wrkMast.getSteNo();
                            SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, steNo);
                            SteProtocol steProtocol = steThread.getSteProtocol();
                            if (steProtocol == null) { continue; }
                            if (steProtocol.isIdle()) {
                                // 命令下发区 --------------------------------------------------------------------------
                                SteCommand steCommand = new SteCommand();
                                steCommand.setSteNo(steNo); // 穿梭车编号
                                steCommand.setTaskNo(wrkMast.getWrkNo()); // 工作号
                                steCommand.setTaskMode(SteTaskModeType.findInByLoc(wrkMast.getLocNo())); // 任务模式: 搬入库
                                if (!MessageQueue.offer(SlaveType.Ste, steNo, new Task(2, steCommand))) {
                                    News.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", steNo, JSON.toJSON(steCommand));
                                } else {
                                    // 修改工作档状态 7.吊车入库中 => 8.小车搬入库
                                    wrkMast.setWrkSts(8L);
                                    Date now = new Date();
                                    wrkMast.setCrnEndTime(now);
                                    wrkMast.setModiTime(now);
                                    if (wrkMastMapper.updateById(wrkMast) > 0) {
                                        // 堆垛机复位
                                        crnThread.setResetFlag(true);
                                    } else {
                                        News.error("修改工作档状态 7.吊车入库中 => 8.小车搬入库 失败！！，工作号={}", wrkMast.getWrkNo());
                                    }
                                }
                            }
                        }
                    // 入库 ===>> 迁入小车 完成
                    } else if (wrkMast.getWrkSts() == 4) {
                        // 4.迁入小车 ==> 6.小车待入
                        wrkMast.setWrkSts(6L);
                        Date now = new Date();
                        wrkMast.setCrnEndTime(now);
                        wrkMast.setModiTime(now);
                        // 修改成功后复位堆垛机
                        if (wrkMastMapper.updateById(wrkMast) > 0) {
                            // 堆垛机复位
                            crnThread.setResetFlag(true);
                            // 穿梭车重新定位排列层
                            SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, wrkMast.getSteNo());
                            if (!steThread.confirmPos()) {
                                News.error("{}号穿梭车重新定位失败！作业工作档任务号：{}", wrkMast.getSteNo(), wrkMast.getWrkNo());
                            }
                            // 穿梭车去待机位
                            BasSte basSte = basSteService.selectById(wrkMast.getSteNo());
                            SteCommand steCommand = new SteCommand();
                            steCommand.setSteNo(wrkMast.getSteNo()); // 穿梭车编号
                            steCommand.setTaskNo(9999); // 工作号
                            steCommand.setTaskMode(SteTaskModeType.findWaiting(basSte.getRow())); // 任务模式:  去近点 等待堆垛机叉取
//                        steCommand.setRow(Utils.getGroupRow(steProtocol.getRow().intValue()).shortValue());
//                        steCommand.setBay(steProtocol.getBay());
//                        steCommand.setLev(steProtocol.getLev());
                            if (!MessageQueue.offer(SlaveType.Ste, wrkMast.getSteNo(), new Task(2, steCommand))) {
                                News.error("穿梭车待机位命令下发失败，穿梭车号={}，任务数据={}", wrkMast.getSteNo(), JSON.toJSON(steCommand));
                            }
                        } else {
                            News.error("修改工作档状态 4.迁入小车 => 6.小车待入 失败！！，工作号={}", wrkMast.getWrkNo());
                        }
                        // 入库 ===>> 迁出小车 完成
                    } else if (wrkMast.getWrkSts() == 5) {
                        // 5.迁出小车 ==> 6.小车待入
                        wrkMast.setWrkSts(6L);
                        Date now = new Date();
                        wrkMast.setCrnEndTime(now);
                        wrkMast.setModiTime(now);
                        // 修改成功后复位堆垛机
                        if (wrkMastMapper.updateById(wrkMast) > 0) {
                            // 堆垛机复位
                            crnThread.setResetFlag(true);
                            // 穿梭车重新定位排列层
                            SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, wrkMast.getSteNo());
                            if (!steThread.confirmPos()) {
                                News.error("{}号穿梭车重新定位失败！作业工作档任务号：{}", wrkMast.getSteNo(), wrkMast.getWrkNo());
                            }
                            // 穿梭车去待机位
                            BasSte basSte = basSteService.selectById(wrkMast.getSteNo());
                            SteCommand steCommand = new SteCommand();
                            steCommand.setSteNo(wrkMast.getSteNo()); // 穿梭车编号
                            steCommand.setTaskNo(9999); // 工作号
                            steCommand.setTaskMode(SteTaskModeType.findWaiting(basSte.getRow())); // 任务模式:  去近点 等待堆垛机叉取
//                        steCommand.setRow(Utils.getGroupRow(steProtocol.getRow().intValue()).shortValue());
//                        steCommand.setBay(steProtocol.getBay());
//                        steCommand.setLev(steProtocol.getLev());
                            if (!MessageQueue.offer(SlaveType.Ste, wrkMast.getSteNo(), new Task(2, steCommand))) {
                                News.error("穿梭车待机位命令下发失败，穿梭车号={}，任务数据={}", wrkMast.getSteNo(), JSON.toJSON(steCommand));
                            }
                        } else {
                            News.error("修改工作档状态 5.迁出小车 => 6.小车待入 失败！！，工作号={}", wrkMast.getWrkNo());
                        }
                        // 出库 ===>> 迁入小车 完成
                    } else if (wrkMast.getWrkSts() == 13) {
                        // 给穿梭车下发命令
                        Integer steNo = wrkMast.getSteNo();
                        SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, steNo);
                        SteProtocol steProtocol = steThread.getSteProtocol();
                        if (steProtocol == null) { continue; }
                        // 穿梭车重新定位排列层
                        if (!steThread.confirmPos()) {
                            News.error("{}号穿梭车重新定位失败！作业工作档任务号：{}", wrkMast.getSteNo(), wrkMast.getWrkNo());
                        }
                        // 命令下发区 --------------------------------------------------------------------------
                        SteCommand steCommand = new SteCommand();
                        steCommand.setSteNo(steNo); // 穿梭车编号
                        steCommand.setTaskNo(wrkMast.getWrkNo()); // 工作号
                        steCommand.setTaskMode(SteTaskModeType.findOutByLoc(wrkMast.getSourceLocNo())); // 任务模式:  搬出库
                        if (!MessageQueue.offer(SlaveType.Ste, steNo, new Task(2, steCommand))) {
                            News.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", steNo, JSON.toJSON(steCommand));
                        } else {
                            // 13.迁入小车 ==> 14.小车搬出库
                            wrkMast.setWrkSts(14L);
                            Date now = new Date();
                            wrkMast.setCrnEndTime(now);
                            wrkMast.setModiTime(now);
                            LocMast locMast = locMastService.selectById(wrkMast.getSourceLocNo());
                            Integer outCrnNo = locMastService.getOutCrnNo(locMast);
                            wrkMast.setCrnNo(outCrnNo);
                            // 修改成功后复位堆垛机
                            if (wrkMastMapper.updateById(wrkMast) > 0) {
                                // 堆垛机复位
                                crnThread.setResetFlag(true);
                            } else {
                                News.error("修改工作档状态 13.迁入小车 ==> 14.小车搬出库 失败！！，工作号={}", wrkMast.getWrkNo());
                            }
                        }
                        // 移库 ===>> 堆垛机搬至目标库位组 完成
                    } else if (wrkMast.getWrkSts() == 16) {
                        // 16.吊车出库中 ==> 17.出库完成
                        wrkMast.setWrkSts(17L);
                        Date now = new Date();
                        wrkMast.setCrnEndTime(now);
                        wrkMast.setModiTime(now);
                        LocMast locMast = locMastService.selectById(wrkMast.getSourceLocNo());
                        Integer outCrnNo = locMastService.getOutCrnNo(locMast);
                        wrkMast.setCrnNo(outCrnNo);
                        // 修改成功后复位堆垛机
                        if (wrkMastMapper.updateById(wrkMast) > 0) {
                            // 堆垛机复位
                            crnThread.setResetFlag(true);
                        } else {
                            News.error("修改工作档状态 16.吊车出库中 ==> 17.出库完成 失败！！，工作号={}", wrkMast.getWrkNo());
                        }
                    }
                }
            }
        }
    }

    /**
     * 执行对工作档的完成操作
     */
    public synchronized void carGenerateStore() {
        Date now = new Date();
        for (SteSlave ste : slaveProperties.getSte()) {
            // 获取穿梭车信息
            SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, ste.getId());
            SteProtocol steProtocol = steThread.getSteProtocol();
            if (steProtocol == null) { continue; }
            if (steProtocol.getWaiting() && steProtocol.getTaskNo() != 0) {
                if (steProtocol.getTaskNo() == 9999) {
                    steThread.setResetFlag(true);
                } else {
                    // 查询是否有待入库的任务
                    WrkMast wrkMast = wrkMastMapper.selectCarWaiting(steProtocol.getTaskNo().intValue());
                    if (wrkMast == null) {
                        // 充电任务
                        WrkCharge wrkCharge = wrkChargeService.selectById(steProtocol.getTaskNo());
                        if (wrkCharge == null) {
                            continue;
                        } else {
                            if (wrkCharge.getWrkSts() == 21) {
                                // 21.准备充电 ===>> 22.小车待搬
                                wrkCharge.setWrkSts(22L);
                                if (!wrkChargeService.updateById(wrkCharge)) {
                                    News.error("修改充电任务状态 21.准备充电 ===>> 22.小车待搬 失败！！，工作号={}", wrkCharge.getWrkNo());
                                } else {
                                    steThread.setResetFlag(true);
                                }
                            } else if (wrkCharge.getWrkSts() == 25) {
                                // 25.小车走行 ===>> 26.等待充电
                                wrkCharge.setWrkSts(26L);
                                if (!wrkChargeService.updateById(wrkCharge)) {
                                    News.error("修改充电任务状态 25.小车走行 ===>> 26.等待充电 失败！！，工作号={}", wrkCharge.getWrkNo());
                                } else {
                                    steThread.setResetFlag(true);
                                }
                            }
//                            else if (wrkCharge.getWrkSts() == 29) {
//                                // 29.开始充电 ===>> 30.完成充电
//                                wrkCharge.setWrkSts(30L);
//                                if (!wrkChargeService.updateById(wrkCharge)) {
//                                    News.error("修改充电任务状态 29.开始充电 ===>> 30.完成充电 失败！！，工作号={}", wrkCharge.getWrkNo());
//                                } else {
//                                    steThread.setResetFlag(true);
//                                }
//                            }
                            else if (wrkCharge.getWrkSts() == 32) {
                                // 32.小车走行 ===>> 33.小车待搬
                                wrkCharge.setWrkSts(33L);
                                if (!wrkChargeService.updateById(wrkCharge)) {
                                    News.error("修改演示任务状态 32.小车走行 ===>> 33.小车待搬 失败！！，工作号={}", wrkCharge.getWrkNo());
                                } else {
                                    steThread.setResetFlag(true);
                                }
                            } else if (wrkCharge.getWrkSts() == 36) {
                                // 36.小车走行 ===>> 37.演示完成
                                wrkCharge.setWrkSts(37L);
                                if (!wrkChargeService.updateById(wrkCharge)) {
                                    News.error("修改演示任务状态 36.小车走行 ===>> 37.演示完成 失败！！，工作号={}", wrkCharge.getWrkNo());
                                } else {
                                    steThread.setResetFlag(true);
                                }
                            }  else if (wrkCharge.getWrkSts() == 44) {
                                // 44.小车走行 ===>> 45.小车待搬
                                wrkCharge.setWrkSts(45L);
                                if (!wrkChargeService.updateById(wrkCharge)) {
                                    News.error("修改演示任务状态 44.小车走行 ===>> 45.小车待搬 失败！！，工作号={}", wrkCharge.getWrkNo());
                                } else {
                                    steThread.setResetFlag(true);
                                }
                            }
                        }
                    }

                    if (wrkMast == null) { continue; }
                    switch (wrkMast.getWrkSts().intValue()) {
                        case 2:
                            // 修改工作档状态 2.设备上走 => 3.小车待搬
                            wrkMast.setWrkSts(3L);
                            wrkMast.setModiTime(now);
                            if (wrkMastMapper.updateById(wrkMast) == 0) {
                                News.error("修改工作档状态 2.设备上走 => 3.小车待搬 失败！！，工作号={}", wrkMast.getWrkNo());
                            } else {
                                steThread.setResetFlag(true);
                            }
                            break;
                        case 8:
                            // 修改工作档状态 8.小车搬入库 => 9.入库完成
                            wrkMast.setWrkSts(9L);
                            wrkMast.setModiTime(now);
                            if (wrkMastMapper.updateById(wrkMast) == 0) {
                                News.error("修改工作档状态 8.小车搬入库 => 9.入库完成 失败！！，工作号={}", wrkMast.getWrkNo());
                            } else {
                                steThread.setResetFlag(true);
                            }
                            break;
                        case 11:
                            if (wrkMast.getIoType() != 11) {
                                // 修改工作档状态 11.生成出库ID => 12.小车待搬
                                wrkMast.setWrkSts(12L);
                            } else {
                                if (Cools.isEmpty(wrkMast.getMk())) {
                                    News.error("移库工作档没有流程标记！！，工作号={}", wrkMast.getWrkNo());
                                } else {
                                    if (wrkMast.getMk().equals("I")) {
                                        String locNo = wrkMast.getLocNo();
                                        if (Utils.getGroupRow(locNo, false).equals(Utils.getGroupRow(steProtocol.getRow().intValue(), false))
                                                && steProtocol.getBay() == Utils.getBay(locNo)
                                                && steProtocol.getLev() == Utils.getLev(locNo)) {
                                            // 修改工作档状态 11.生成出库ID => 6.小车待入
                                            wrkMast.setWrkSts(6L);
                                        } else {
                                            // 修改工作档状态 11.生成出库ID => 3.小车待搬
                                            wrkMast.setWrkSts(3L);
                                        }
                                    } else if (wrkMast.getMk().equals("O")) {
                                        // 修改工作档状态 11.生成出库ID => 12.小车待搬
                                        wrkMast.setWrkSts(12L);
                                    }
                                }
                            }
                            wrkMast.setModiTime(now);
                            if (wrkMastMapper.updateById(wrkMast) == 0) {
                                News.error("修改工作档状态 11.生成出库ID => 12.小车待搬 失败！！，工作号={}", wrkMast.getWrkNo());
                            } else {
                                steThread.setResetFlag(true);
                            }
                            break;
                        case 14:
                            // 修改工作档状态 14.小车搬出库 => 15.等待吊车
                            wrkMast.setWrkSts(15L);
                            wrkMast.setModiTime(now);
                            if (wrkMastMapper.updateById(wrkMast) == 0) {
                                News.error("修改工作档状态 14.小车搬出库 => 15.等待吊车 失败！！，工作号={}", wrkMast.getWrkNo());
                            } else {
                                steThread.setResetFlag(true);
                            }
                            break;
                    }
                }
            }
        }
    }

    /**
     * 异常信息记录
     */
    public void recErr() {
        try {
            this.recShuttleErr();
            this.recCrnErr();
            this.recSteErr();
        } catch (Exception e) {
            News.error("recErr fail", e);
        }
@@ -3034,235 +1777,6 @@
            }
        }
    }

    /**
     * 堆垛机异常信息记录
     */
    private void recCrnErr(){
        Date now = new Date();
        for (CrnSlave crn : slaveProperties.getCrn()) {
            // 获取堆垛机信息
            CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, crn.getId());
            CrnProtocol crnProtocol = crnThread.getCrnProtocol();
            if (crnProtocol == null) {
                continue;
            }
            // 有任务
            if (crnProtocol.getTaskNo() != 0) {
                BasErrLog latest = basErrLogService.findLatestByTaskNo(crn.getId(), crnProtocol.getTaskNo().intValue());
                // 有异常
                if (latest == null) {
                    if (crnProtocol.getAlarm() != null && crnProtocol.getAlarm() > 0) {
                        WrkMast wrkMast = wrkMastMapper.selectById(crnProtocol.getTaskNo());
                        if (wrkMast == null) {
                            continue;
                        }
                        BasCrnError crnError = basCrnErrorMapper.selectById(crnProtocol.getAlarm());
                        String errName = crnError==null? "未知异常":crnError.getErrName();
                        BasErrLog basErrLog = new BasErrLog(
                                null,    // 编号
                                wrkMast.getWrkNo(),    // 工作号
                                now,    // 发生时间
                                null,    // 结束时间
                                wrkMast.getWrkSts(),    // 工作状态
                                wrkMast.getIoType(),    // 入出库类型
                                crn.getId(),    // 堆垛机
                                null,    // plc
                                wrkMast.getLocNo(),    // 目标库位
                                wrkMast.getStaNo(),    // 目标站
                                wrkMast.getSourceStaNo(),    // 源站
                                wrkMast.getSourceLocNo(),    // 源库位
                                wrkMast.getBarcode(),    // 条码
                                (int) crnProtocol.getAlarm(),    // 异常码
                                errName,    // 异常
                                1,    // 异常情况
                                now,    // 添加时间
                                null,    // 添加人员
                                now,    // 修改时间
                                null,    // 修改人员
                                "任务中异常"    // 备注
                        );
                        if (!basErrLogService.insert(basErrLog)) {
                            News.error("堆垛机plc异常记录失败 ===>> [id:{}] [error:{}]", crn.getId(), errName);
                        }
                    }
                } else {
                    // 异常修复
                    if (crnProtocol.getAlarm() == null || crnProtocol.getAlarm() == 0) {
                        latest.setEndTime(now);
                        latest.setUpdateTime(now);
                        latest.setStatus(2);
                        if (!basErrLogService.updateById(latest)) {
                            News.error("堆垛机plc异常记录修复失败 ===>> [id:{}] [errLogId:{}]", crn.getId(), latest.getId());
                        }
                    }
                }
            // 无任务
            } else {
                BasErrLog latest = basErrLogService.findLatest(crn.getId());
                // 有异常
                if (crnProtocol.getAlarm() != null && crnProtocol.getAlarm() > 0) {
                    // 记录新异常
                    if (latest == null || (latest.getErrCode() != crnProtocol.getAlarm().intValue())) {
                        BasCrnError crnError = basCrnErrorMapper.selectById(crnProtocol.getAlarm());
                        String errName = crnError==null? "未知异常":crnError.getErrName();
                        BasErrLog basErrLog = new BasErrLog(
                                null,    // 编号
                                null,    // 工作号
                                now,    // 发生时间
                                null,    // 结束时间
                                null,    // 工作状态
                                null,    // 入出库类型
                                crn.getId(),    // 堆垛机
                                null,    // plc
                                null,    // 目标库位
                                null,    // 目标站
                                null,    // 源站
                                null,    // 源库位
                                null,    // 条码
                                (int)crnProtocol.getAlarm(),    // 异常码
                                errName,    // 异常
                                1,    // 异常情况
                                now,    // 添加时间
                                null,    // 添加人员
                                now,    // 修改时间
                                null,    // 修改人员
                                "无任务异常"    // 备注
                        );
                        if (!basErrLogService.insert(basErrLog)) {
                            News.error("堆垛机plc异常记录失败 ===>> [id:{}] [error:{}]", crn.getId(), errName);
                        }
                    }
                // 无异常
                } else {
                    // 异常修复
                    if (latest != null && latest.getStatus() == 1) {
                        latest.setEndTime(now);
                        latest.setUpdateTime(now);
                        latest.setStatus(2);
                        if (!basErrLogService.updateById(latest)) {
                            News.error("堆垛机plc异常记录修复失败 ===>> [id:{}] [errLogId:{}]", crn.getId(), latest.getId());
                        }
                    }
                }
            }
        }
    }

    /**
     * 穿梭车异常信息记录
     */
    private void recSteErr(){
        Date now = new Date();
        for (SteSlave ste : slaveProperties.getSte()) {
            // 获取堆垛机信息
            SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, ste.getId());
            SteProtocol steProtocol = steThread.getSteProtocol();
            if (steProtocol == null) {
                continue;
            }
            // 有任务
            if (steProtocol.getTaskNo() != 0) {
                BasSteErrLog latest = basSteErrLogService.findLatestByTaskNo(ste.getId(), steProtocol.getTaskNo().intValue());
                // 有异常
                if (latest == null) {
                    if (steProtocol.getAlarm() != null && steProtocol.isAlarm()) {
                        WrkMast wrkMast = wrkMastMapper.selectById(steProtocol.getTaskNo());
                        if (wrkMast == null) {
                            continue;
                        }
                        BasSteErr steErr = basSteErrService.selectById(steProtocol.getAlarm());
                        String errName = steErr==null? "未知异常":steErr.getErrName();
                        BasSteErrLog basSteErrLog = new BasSteErrLog(
                                null,    // 编号
                                wrkMast.getWrkNo(),    // 工作号
                                now,    // 发生时间
                                null,    // 结束时间
                                wrkMast.getWrkSts(),    // 工作状态
                                wrkMast.getIoType(),    // 入出库类型
                                ste.getId(),    // 堆垛机
                                null,    // plc
                                wrkMast.getLocNo(),    // 目标库位
                                wrkMast.getStaNo(),    // 目标站
                                wrkMast.getSourceStaNo(),    // 源站
                                wrkMast.getSourceLocNo(),    // 源库位
                                wrkMast.getBarcode(),    // 条码
                                (int) steProtocol.getAlarm(),    // 异常码
                                errName,    // 异常
                                1,    // 异常情况
                                now,    // 添加时间
                                null,    // 添加人员
                                now,    // 修改时间
                                null,    // 修改人员
                                "任务中异常"    // 备注
                        );
                        if (!basSteErrLogService.insert(basSteErrLog)) {
                            News.error("穿梭车plc异常记录失败 ===>> [id:{}] [error:{}]", ste.getId(), errName);
                        }
                    }
                } else {
                    // 异常修复
                    if (steProtocol.getAlarm() == null || !steProtocol.isAlarm()) {
                        latest.setEndTime(now);
                        latest.setUpdateTime(now);
                        latest.setStatus(2);
                        if (!basSteErrLogService.updateById(latest)) {
                            News.error("穿梭车plc异常记录修复失败 ===>> [id:{}] [errLogId:{}]", ste.getId(), latest.getId());
                        }
                    }
                }
                // 无任务
            } else {
                BasSteErrLog latest = basSteErrLogService.findLatest(ste.getId());
                // 有异常
                if (steProtocol.getAlarm() != null && steProtocol.isAlarm()) {
                    // 记录新异常
                    if (latest == null || (latest.getErrCode() != steProtocol.getAlarm().intValue())) {
                        BasSteErr steErr = basSteErrService.selectById(steProtocol.getAlarm());
                        String errName = steErr==null? "未知异常":steErr.getErrName();
                        BasSteErrLog basSteErrLog = new BasSteErrLog(
                                null,    // 编号
                                null,    // 工作号
                                now,    // 发生时间
                                null,    // 结束时间
                                null,    // 工作状态
                                null,    // 入出库类型
                                ste.getId(),    // 堆垛机
                                null,    // plc
                                null,    // 目标库位
                                null,    // 目标站
                                null,    // 源站
                                null,    // 源库位
                                null,    // 条码
                                (int)steProtocol.getAlarm(),    // 异常码
                                errName,    // 异常
                                1,    // 异常情况
                                now,    // 添加时间
                                null,    // 添加人员
                                now,    // 修改时间
                                null,    // 修改人员
                                "无任务异常"    // 备注
                        );
                        if (!basSteErrLogService.insert(basSteErrLog)) {
                            News.error("穿梭车plc异常记录失败 ===>> [id:{}] [error:{}]", ste.getId(), errName);
                        }
                    }
                    // 无异常
                } else {
                    // 异常修复
                    if (latest != null && latest.getStatus() == 1) {
                        latest.setEndTime(now);
                        latest.setUpdateTime(now);
                        latest.setStatus(2);
                        if (!basSteErrLogService.updateById(latest)) {
                            News.error("穿梭车plc异常记录修复失败 ===>> [id:{}] [errLogId:{}]", ste.getId(), latest.getId());
                        }
                    }
                }
            }
        }
    }


    // -------------------------------------------------------------------------------

@@ -3787,310 +2301,6 @@
    }

    /**
     * 小车电量检测 ===>> 发起充电
     */
    @SuppressWarnings("serial")
    public synchronized void loopSteCharge() {
        if (!Cools.isEmpty(wrkMastMapper.selectAllC())){
            return;
        }
        if (null != wrkChargeService.selectWorking(null, WrkChargeType.reset)) {
            return;
        }
        if (null != wrkChargeService.selectWorking(null, WrkChargeType.charge)) {
            return;
        }
        SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, 1);
        for (SteSlave ste : slaveProperties.getSte()) {
            SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, ste.getId());
            SteProtocol steProtocol = steThread.getSteProtocol();
            BasSte basSte = basSteService.selectById(ste.getId());
            if (Cools.isEmpty(steProtocol, basSte)) { continue; }
            try {
                // 在线 空闲   无作业标记   不在充电
                if (steProtocol.getMode() == 0
                        || !steProtocol.statusType.equals(SteStatusType.IDLE)
                        || basSte.getPakMk().equals("Y")
                        || basSte.getAutoCharge().equals("N")
//                        || steProtocol.getChargeStatus() == 1
                ) {
                    continue;
                }
                if (!steProtocol.isEnable()) {
                    continue;
                }
                if (steProtocol.getCharge() > Float.parseFloat(basSte.getChargeLine())) {
                    continue;
                }
                WrkCharge wrkCharge = wrkChargeService.selectWorking(null, WrkChargeType.charge);

                if (wrkCharge == null && steProtocol.getChargeStatus() == 0) {
                    // 寻找空闲充电桩
                    SteChargeType steCharge = null;
                    do {
                        String locNo;
                        if (devpThread.charge0) {
                            SteChargeType first = SteChargeType.FIRST;
                            locNo = first.locNo;
                            if (basSteService.hasCarOfLocNo(locNo) == null
                                && wrkChargeService.selectWorkingOfCharge(first.ssbm) == null) {
                                steCharge = first;
                                break;
                            }
                        }
//                        if (!devpThread.charge1) {
//                            SteChargeType second = SteChargeType.SECOND;
//                            locNo = second.locNo;
//                            if (basSteService.hasCarOfLocNo(locNo) == null
//                                && wrkChargeService.selectWorkingOfCharge(second.ssbm) == null) {
//                                steCharge = second;
//                                break;
//                            }
//                        }
//                        if (!devpThread.charge2) {
//                            SteChargeType third = SteChargeType.THIRD;
//                            locNo = third.locNo;
//                            if (basSteService.hasCarOfLocNo(locNo) == null
//                                && wrkChargeService.selectWorkingOfCharge(third.ssbm) == null) {
//                                steCharge = third;
//                                break;
//                            }
//                        }
                        break;
                    } while (false);

                    if (steCharge == null) {
//                        News.warn("{}号小车【电量：{}】充电失败，原因：没有空闲充电桩。", ste.getId(), steProtocol.getCharge());
                        continue;
                    }
                    String chargeLocNo = steCharge.locNo;
                    wrkCharge = new WrkCharge();
                    wrkCharge.setSteNo(ste.getId());
                    wrkCharge.setCharge(steCharge.ssbm);
                    wrkCharge.setWrkNo(commonService.getChargeWorkNo(4));
                    wrkCharge.setWrkSts(21L);   // 21.准备充电
                    wrkCharge.setCrnNo(1);  // 固定1号堆垛机
                    wrkCharge.setIoPri((double) 10);
                    wrkCharge.setLocNo(chargeLocNo);
                    wrkCharge.setMemo("charge");
                    wrkCharge.setAppeTime(new Date());
                    if (!wrkChargeService.insert(wrkCharge)) {
                        News.error("保存{}号穿梭车充电任务失败!!!", ste.getId());
                        continue;
                    }

                    // 处于充电库位组
                    if ( 0<steProtocol.getRow().intValue() && steProtocol.getRow().intValue()<=4
                            && steProtocol.getBay().intValue() == Utils.getBay(chargeLocNo)
                            && steProtocol.getLev().intValue() == Utils.getLev(chargeLocNo)) {
                        // 修改工作档状态 21.准备充电 => 24.小车到达
                        wrkCharge.setWrkSts(24L);
                        wrkCharge.setModiTime(new Date());
                        if (!wrkChargeService.updateById(wrkCharge)) {
                            News.error("修改充电任务状态 21.准备充电 => 24.小车到达 失败！！，工作号={}", wrkCharge.getWrkNo());
                        }
                    } else {
                        this.letCarBeWaiting(wrkCharge, ste.getId());
                    }

                    break;
                }
            } catch (Exception e) {
                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                News.error("loopSteCharge fail", e);
            }
        }
    }

    /**
     * 执行小车充电任务
     */
    public synchronized void executeSteCharge() {
        WrkCharge wrkCharge = wrkChargeService.selectWorking(null, WrkChargeType.charge);
        SteThread steThread = (SteThread) SlaveConnection.get(SlaveType.Ste, 1);
        SteProtocol steProtocol = steThread.getSteProtocol();
        if (null == wrkCharge) {
            try{
                if (steProtocol.getChargeStatus()==(short)0 && steProtocol.isBrushConnect()){
                    SteCommand steCommand = new SteCommand();
                    steCommand.setSteNo(1); // 穿梭车编号
                    steCommand.setTaskNo(10060); // 工作号
                    steCommand.setTaskMode(SteTaskModeType.CLOSE_CHARGE); // 任务模式: 断开充电
                    if (!MessageQueue.offer(SlaveType.Ste, 1, new Task(2, steCommand))) {
                        News.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", wrkCharge.getSteNo(), JSON.toJSON(steCommand));
                    }
                }
            }catch (Exception e){
                return;
            }
            return;
        }
        Integer steNo = wrkCharge.getSteNo();

        BasSte basSte = basSteService.selectById(steNo);
        if (Cools.isEmpty(steProtocol, basSte)) { return; }
        if (steProtocol.getMode() == 0
                || !steProtocol.statusType.equals(SteStatusType.IDLE)
                || basSte.getPakMk().equals("Y")
                || basSte.getAutoCharge().equals("N")
//                || steProtocol.getChargeStatus() == 1
        ) {
            return;
        }
        if (!steProtocol.isEnable()) {
            return;
        }
        if (steProtocol.getCharge() > Float.parseFloat(basSte.getChargeLine())+40) {
            MessageQueue.offer(SlaveType.Devp, 1, new Task(3, 999));//中断充电标记
            wrkCharge.setWrkSts(30L);
            if (!wrkChargeService.updateById(wrkCharge)) {
                News.error("修改充电任务状态 29.开始充电 ===>> 30.完成充电 失败！！，工作号={}", wrkCharge.getWrkNo());
            }else {
                SteCommand steCommand = new SteCommand();
                steCommand.setSteNo(wrkCharge.getSteNo()); // 穿梭车编号
                steCommand.setTaskNo(wrkCharge.getWrkNo()); // 工作号
                steCommand.setTaskMode(SteTaskModeType.CLOSE_CHARGE); // 任务模式: 断开充电
                if (!MessageQueue.offer(SlaveType.Ste, wrkCharge.getSteNo(), new Task(2, steCommand))) {
                    News.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", wrkCharge.getSteNo(), JSON.toJSON(steCommand));
                }
            }
            return;
        }else if (steProtocol.getCharge() > Float.parseFloat(basSte.getChargeLine()) && steProtocol.getChargeStatus()==(short)0 && steProtocol.isBrushConnect()) {
            MessageQueue.offer(SlaveType.Devp, 1, new Task(3, 999));//中断充电标记
            wrkCharge.setWrkSts(30L);
            if (!wrkChargeService.updateById(wrkCharge)) {
                News.error("修改充电任务状态 29.开始充电 ===>> 30.完成充电 失败！！，工作号={}", wrkCharge.getWrkNo());
            }else {
                SteCommand steCommand = new SteCommand();
                steCommand.setSteNo(wrkCharge.getSteNo()); // 穿梭车编号
                steCommand.setTaskNo(wrkCharge.getWrkNo()); // 工作号
                steCommand.setTaskMode(SteTaskModeType.CLOSE_CHARGE); // 任务模式: 断开充电
                if (!MessageQueue.offer(SlaveType.Ste, wrkCharge.getSteNo(), new Task(2, steCommand))) {
                    News.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", wrkCharge.getSteNo(), JSON.toJSON(steCommand));
                }
            }
            return;
        }
        try {
            // filter
            if (wrkCharge.getWrkSts() < 28 && steProtocol.getChargeStatus() == 1) {
                return;
            }

            // 22.小车待搬
            if (wrkCharge.getWrkSts() == 22) {

                // 入出库任务优先
                if (null != wrkMastMapper.selectWorkingByCrn(wrkCharge.getCrnNo())) {
                    return;
                }

                LocMast locMast = locMastService.selectById(basSte.getIdleLoc());

                // 搬小车至小车走向通道
                CrnThread crnThread = (CrnThread) SlaveConnection.get(SlaveType.Crn, wrkCharge.getCrnNo());
                CrnProtocol crnProtocol = crnThread.getCrnProtocol();
                if (crnProtocol == null) { return; }
                // 只有当堆垛机空闲 并且 无任务时才继续执行
                if (crnProtocol.getStatusType() == CrnStatusType.IDLE && crnProtocol.getTaskNo() == 0 && crnProtocol.getModeType() == CrnModeType.AUTO) {
                    // 堆垛机命令下发区 --------------------------------------------------------------------------
                    CrnCommand crnCommand = new CrnCommand();
                    crnCommand.setCrnNo(wrkCharge.getCrnNo()); // 堆垛机编号
                    crnCommand.setTaskNo(wrkCharge.getWrkNo().shortValue()); // 工作号
                    crnCommand.setAckFinish((short) 0);  // 任务完成确认位
                    crnCommand.setTaskMode(CrnTaskModeType.STE_MOVE); // 任务模式:  库位移转
                    crnCommand.setSourcePosX(Utils.getGroupRow(steProtocol.getRow().intValue(), true).shortValue());     // 源库位排
                    crnCommand.setSourcePosY(steProtocol.getBay());     // 源库位列
                    crnCommand.setSourcePosZ(steProtocol.getLev());     // 源库位层
                    crnCommand.setDestinationPosX(Utils.getGroupRow(locMast.getLocNo(), true).shortValue());     // 目标库位排
                    crnCommand.setDestinationPosY(locMast.getBay1().shortValue());     // 目标库位列
                    crnCommand.setDestinationPosZ(locMast.getLev1().shortValue());     // 目标库位层
                    if (!MessageQueue.offer(SlaveType.Crn, wrkCharge.getCrnNo(), new Task(2, crnCommand))) {
                        News.error("堆垛机命令下发失败，堆垛机号={}，任务数据={}", wrkCharge.getCrnNo(), JSON.toJSON(crnCommand));
                    } else {
                        // 修改穿梭车运行中排列层
                        steThread.modifyPos(Utils.getGroupRow(locMast.getLocNo(), true), locMast.getBay1(), locMast.getLev1());
                        // 修改工作档状态 22.小车待搬 => 23.吊车搬运
                        Date now = new Date();
                        wrkCharge.setWrkSts(23L);
                        wrkCharge.setCrnStrTime(now);
                        wrkCharge.setModiTime(now);
                        if (!wrkChargeService.updateById(wrkCharge)) {
                            News.error("修改工作档状态 22.小车待搬 => 23.吊车搬运 失败！！，工作号={}", wrkCharge.getWrkNo());
                        }
                    }
                }

            } else if (wrkCharge.getWrkSts() == 24L) {
                // 小车行驶通道
                if (steProtocol.statusType.equals(SteStatusType.IDLE) && steProtocol.getPakMk().equals("N")) {
                    if (steProtocol.getChargeStatus() == 1) { return; }
                    // 命令下发区 --------------------------------------------------------------------------
                    SteCommand steCommand = new SteCommand();
                    steCommand.setSteNo(wrkCharge.getSteNo()); // 穿梭车编号
                    steCommand.setTaskNo(wrkCharge.getWrkNo()); // 工作号
                    steCommand.setTaskMode(SteTaskModeType.BACK_ORIGIN);  // 去右端

                    steCommand.setRow(Utils.getGroupRow(steProtocol.getRow().intValue(), false).shortValue());
                    steCommand.setBay(steProtocol.getBay());
                    steCommand.setLev(steProtocol.getLev());
                    if (!MessageQueue.offer(SlaveType.Ste, wrkCharge.getSteNo(), new Task(2, steCommand))) {
                        News.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", wrkCharge.getSteNo(), JSON.toJSON(steCommand));
                    } else {
                        // 修改工作档状态 24.小车到达 ===> 25.小车走行
                        wrkCharge.setWrkSts(25L);
                        Date now = new Date();
                        wrkCharge.setCrnEndTime(now);
                        wrkCharge.setModiTime(now);
                        if (!wrkChargeService.updateById(wrkCharge)) {
                            News.error("修改充电任务状态 24.小车到达 ===> 25.小车走行 失败！！，工作号={}", wrkCharge.getWrkNo());
                        }
                    }
                }
            } else if (wrkCharge.getWrkSts() == 26) {
                //26.等待充电 ===>
                // 穿梭车下发充电任务
                SteCommand steCommand = new SteCommand();
                steCommand.setSteNo(wrkCharge.getSteNo()); // 穿梭车编号
                steCommand.setTaskNo(wrkCharge.getWrkNo()); // 工作号
                steCommand.setTaskMode(SteTaskModeType.CHARGE_LEFT); // 任务模式: 充电
                if (!MessageQueue.offer(SlaveType.Ste, wrkCharge.getSteNo(), new Task(2, steCommand))) {
                    News.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", wrkCharge.getSteNo(), JSON.toJSON(steCommand));
                } else {
                    // 28.充电就绪 ===>> 29.开始充电
                    wrkCharge.setWrkSts(29L);
                    if (!wrkChargeService.updateById(wrkCharge)) {
                        News.error("修改充电任务状态 28.充电就绪 ===>> 29.开始充电 失败！！，工作号={}", wrkCharge.getWrkNo());
                    }
                }
            } else if (wrkCharge.getWrkSts() == 29) {
                Float idle2 = steProtocol.isIdle2();
                String chargeLine = SpringUtils.getBean(BasSteService.class).selectById(1).getChargeLine();
                if (idle2<(Float.parseFloat(chargeLine)+2)){
                    MessageQueue.offer(SlaveType.Devp, 1, new Task(3, 666));//充电标记
                }else if (idle2 >= 100f){
                    MessageQueue.offer(SlaveType.Devp, 1, new Task(3, 999));//中断充电标记
                    // 29.开始充电 ===>> 30.完成充电
                    wrkCharge.setWrkSts(30L);
                    if (!wrkChargeService.updateById(wrkCharge)) {
                        News.error("修改充电任务状态 29.开始充电 ===>> 30.完成充电 失败！！，工作号={}", wrkCharge.getWrkNo());
                    }else {
                        SteCommand steCommand = new SteCommand();
                        steCommand.setSteNo(wrkCharge.getSteNo()); // 穿梭车编号
                        steCommand.setTaskNo(wrkCharge.getWrkNo()); // 工作号
                        steCommand.setTaskMode(SteTaskModeType.CLOSE_CHARGE); // 任务模式: 断开充电
                        if (!MessageQueue.offer(SlaveType.Ste, wrkCharge.getSteNo(), new Task(2, steCommand))) {
                            News.error("穿梭车命令下发失败，穿梭车号={}，任务数据={}", wrkCharge.getSteNo(), JSON.toJSON(steCommand));
                        }
                    }
                }
            }
        } catch (Exception e) {
            News.error("executeSteCharge fail", e);
        }
    }

    /**
     * 轮询充电桩是否有空闲小车
     */
    @Deprecated
@@ -4303,131 +2513,6 @@
                }

            }
        }
    }


    /**
     * 因双深库位阻塞，对浅库位进行移转（出库版)
     * tip：同步
     */
    private void moveLocForDeepLoc(CrnSlave crn, LocMast shallowLoc){
        try {
            List<Integer> rows = locMastService.queryDistinctRow(crn.getId());
            LocMast loc = null;
            for (Integer row : rows) {
                if (Utils.isDeepLoc(slaveProperties, row)) {
                    loc = locMastService.queryFreeLocMast(row, shallowLoc.getLocType1());

                    if (loc != null) {
                        if (Utils.isDeepLoc(slaveProperties, loc.getLocNo())) {
                            String shallowLocNo = Utils.getShallowLoc(slaveProperties, loc.getLocNo());
                            LocMast shallowLoc1 = locMastService.selectById(shallowLocNo);
                            if (!shallowLoc1.getLocSts().equals("O")) {
                                loc = null;
                            }
                        }
                    }

                    if (null != loc) {
                        break;
                    }
                }
            }
            if (null == loc) {
                for (Integer row : rows) {
                    if (Utils.isShallowLoc(slaveProperties, row)) {
                        loc = locMastService.queryFreeLocMast(row, shallowLoc.getLocType1());

                        if (null != loc) {//对应深库位非在库状态,不能移库
                            String deepLoc = Utils.getDeepLoc(slaveProperties, loc.getLocNo());
                            LocMast deepLoc1 = locMastService.selectById(deepLoc);
                            if (!deepLoc1.getLocSts().equals("F") && !deepLoc1.getLocSts().equals("D")) {
                                loc = null;
                            }
                        }

                        if (null != loc) {
                            break;
                        }
                    }
                }
            }
            if (null == loc) {
                News.error("双深库位 --- 浅库位阻塞异常！ 待移转浅库位：" + shallowLoc.getLocNo());
                throw new CoolException("双深库位 --- 浅库位阻塞异常！ 待移转浅库位：" + shallowLoc.getLocNo());
            }

            // 获取工作号
            int workNo = commonService.getWorkNo(0);
            // 保存工作档
            WrkMast wrkMast = new WrkMast();
            wrkMast.setWrkNo(workNo);
            wrkMast.setIoTime(new Date());
            wrkMast.setWrkSts(11L); // 工作状态：11.生成出库ID
            wrkMast.setIoType(11); // 入出库状态： 11.库格移载
            wrkMast.setIoPri(20D);
            wrkMast.setCrnNo(crn.getId());
            wrkMast.setSourceLocNo(shallowLoc.getLocNo()); // 源库位
            wrkMast.setLocNo(loc.getLocNo()); // 目标库位
            wrkMast.setFullPlt(shallowLoc.getFullPlt()); // 满板
            wrkMast.setPicking("N"); // 拣料
            wrkMast.setExitMk("N"); // 退出
            wrkMast.setEmptyMk(shallowLoc.getLocSts().equals("D") ? "Y" : "N"); // 空板
            wrkMast.setBarcode(shallowLoc.getBarcode()); // 托盘码
            wrkMast.setLinkMis("N");
            wrkMast.setAppeTime(new Date());
            wrkMast.setModiTime(new Date());
            int res = wrkMastMapper.insert(wrkMast);
            if (res == 0) {
                News.error("双深库位 --- 保存工作档失败！ 待移转浅库位：" + shallowLoc.getLocNo());
                throw new CoolException("保存工作档失败");
            }
            // 工作档明细保存
            if (shallowLoc.getLocSts().equals("F")) {
                List<LocDetl> locDetls = locDetlService.selectList(new EntityWrapper<LocDetl>().eq("loc_no", shallowLoc.getLocNo()));
                for (LocDetl locDetl : locDetls) {
                    WrkDetl wrkDetl = new WrkDetl();
                    wrkDetl.sync(locDetl);
                    wrkDetl.setWrkNo(workNo);
                    wrkDetl.setIoTime(new Date());
                    wrkDetl.setAnfme(locDetl.getAnfme());
                    wrkDetl.setAppeTime(new Date());
                    wrkDetl.setModiTime(new Date());
                    if (!wrkDetlService.insert(wrkDetl)) {
                        News.error("双深库位 --- 保存工作档明细失败！ 待移转浅库位：" + shallowLoc.getLocNo());
                        throw new CoolException("保存工作档明细失败");
                    }
                }
            }
            // 修改源库位状态
            if (shallowLoc.getLocSts().equals("D") || shallowLoc.getLocSts().equals("F")) {
                shallowLoc.setLocSts("R"); // R.出库预约
                shallowLoc.setModiTime(new Date());
                if (!locMastService.updateById(shallowLoc)) {
                    News.error("双深库位 --- 更新源库位状态失败！ 待移转浅库位：" + shallowLoc.getLocNo());
                    throw new CoolException("更新源库位状态失败");
                }
            } else {
                News.error("双深库位 --- 源库位出库失败！ 待移转浅库位：" + shallowLoc.getLocNo());
                throw new CoolException("源库位出库失败");
            }
            // 修改目标库位状态
            if (loc.getLocSts().equals("O")) {
                loc.setLocSts("S"); // S.入库预约
                loc.setModiTime(new Date());
                if (!locMastService.updateById(loc)) {
                    News.error("双深库位 --- 更新目标库位状态失败！ 待移转浅库位：" + shallowLoc.getLocNo());
                    throw new CoolException("更新目标库位状态失败");
                }
            } else {
                News.error("双深库位 --- 移转失败！ 待移转浅库位：" + shallowLoc.getLocNo());
                throw new CoolException("移转失败");
            }
        } catch (Exception e) {
            News.error("双深库位阻塞，对浅库位进行移转失败", e);
            e.printStackTrace();
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
        }
    }


 src/main/java/com/zy/core/MainProcess.java

@@ -53,12 +53,6 @@

                    //从redis中重启任务
                    mainService.restartTaskFromRedis();
//                    // 拣料、并板、盘点再入库
//                    mainService.stnToCrnStnPick();
//                    // 出库  ===>>  堆垛机出库站到出库站
//                    mainService.crnStnToOutStn();
//                    // 入出库  ===>>  堆垛机入出库作业下发
//                    mainService.crnIoExecute();
                    // 入库  ===>>  四向穿梭车入库作业下发
                    mainService.shuttleIoInExecute();
                    // 出库  ===>>  四向穿梭车出库作业下发
@@ -69,10 +63,6 @@
                    mainService.liftIoExecute();
                    //提升机任务完成
                    mainService.liftFinished();
//                    // 入库  ===>> 执行堆垛机对工作档的完成操作
//                    mainService.storeFinished();
//                    // 入库 ===>> 执行穿梭车对工作档的完成操作
//                    mainService.carGenerateStore();
                    // 异常信息记录
                    mainService.recErr();
                    // 入库  ===>> 空栈板初始化入库,叉车入库站放货
@@ -84,9 +74,6 @@
                    // 穿梭车 ===>> 小车电量检测充电
                    mainService.loopShuttleCharge();
                    mainService.executeShuttleCharge();
//                    // 穿梭车 ===>> 小车电量检测充电
//                    mainService.loopSteCharge();
//                    mainService.executeSteCharge();
                    //出入库模式
                    i++;
                    if (i > 1) {

 src/main/java/com/zy/core/ServerBootstrap.java

@@ -45,10 +45,6 @@
    }

    private void initMq(){
        // 初始化堆垛机mq
        for (Slave crn : slaveProperties.getCrn()) {
            MessageQueue.init(SlaveType.Crn, crn);
        }
        // 初始化输送线mq
        for (Slave devp : slaveProperties.getDevp()) {
            MessageQueue.init(SlaveType.Devp, devp);
@@ -69,10 +65,6 @@
        for (Slave car : slaveProperties.getCar()) {
            MessageQueue.init(SlaveType.Car, car);
        }
        // 初始化穿梭车mq
        for (Slave ste : slaveProperties.getSte()) {
            MessageQueue.init(SlaveType.Ste, ste);
        }
        // 初始化提升机mq
        for (Slave lift : slaveProperties.getLift()) {
            MessageQueue.init(SlaveType.Lift, lift);
@@ -84,20 +76,6 @@
    }

    private void initThread(){
        // 初始化堆垛机线程
        News.info("初始化堆垛机线程...................................................");
        for (CrnSlave crn : slaveProperties.getCrn()) {
            CrnThread crnThread = new SiemensCrnThread(crn);
            new Thread((Runnable) crnThread).start();
            SlaveConnection.put(SlaveType.Crn, crn.getId(), crnThread);
        }
        // 初始化穿梭车线程
        News.info("初始化穿梭车线程...................................................");
        for (SteSlave ste : slaveProperties.getSte()) {
            SteThread steThread = new SteThread(ste);
            new Thread(steThread).start();
            SlaveConnection.put(SlaveType.Ste, ste.getId(), steThread);
        }
        // 初始化输送线线程
        News.info("初始化输送线线程...................................................");
        for (DevpSlave devp : slaveProperties.getDevp()) {

 src/main/java/com/zy/core/cache/MessageQueue.java

@@ -15,10 +15,6 @@
 */
public class MessageQueue {

    // 堆垛机mq交换机
    private static final Map<Integer, LinkedBlockingQueue<Task>> CRN_EXCHANGE = new ConcurrentHashMap<>();
    // 穿梭车mq交换机
    private static final Map<Integer, LinkedBlockingQueue<Task>> STE_EXCHANGE = new ConcurrentHashMap<>();
    // 输送线mq交换机
    private static final Map<Integer, ConcurrentLinkedQueue<Task>> DEVP_EXCHANGE = new ConcurrentHashMap<>();
    // 条码扫描仪mq交换机
@@ -39,12 +35,6 @@
     */
    public static void init(SlaveType type, Slave slave) {
        switch (type) {
            case Crn:
                CRN_EXCHANGE.put(slave.getId(), new LinkedBlockingQueue<>(1));
                break;
            case Ste:
                STE_EXCHANGE.put(slave.getId(), new LinkedBlockingQueue<>(1));
                break;
            case Devp:
                DEVP_EXCHANGE.put(slave.getId(), new ConcurrentLinkedQueue<>());
                break;
@@ -77,10 +67,6 @@
     */
    public static boolean offer(SlaveType type, Integer id, Task task) {
        switch (type) {
            case Crn:
                return CRN_EXCHANGE.get(id).offer(task);
            case Ste:
                return STE_EXCHANGE.get(id).offer(task);
            case Devp:
                return DEVP_EXCHANGE.get(id).offer(task);
            case Barcode:
@@ -106,10 +92,6 @@
     */
    public static Task poll(SlaveType type, Integer id) {
        switch (type) {
            case Crn:
                return CRN_EXCHANGE.get(id).poll();
            case Ste:
                return STE_EXCHANGE.get(id).poll();
            case Devp:
                return DEVP_EXCHANGE.get(id).poll();
            case Barcode:
@@ -134,10 +116,6 @@
     */
    public static Task peek(SlaveType type, Integer id) {
        switch (type) {
            case Crn:
                return CRN_EXCHANGE.get(id).peek();
            case Ste:
                return STE_EXCHANGE.get(id).peek();
            case Devp:
                return DEVP_EXCHANGE.get(id).peek();
            case Barcode:
@@ -159,12 +137,6 @@

    public static void clear(SlaveType type, Integer id){
        switch (type) {
            case Crn:
                CRN_EXCHANGE.get(id).clear();
                break;
            case Ste:
                STE_EXCHANGE.get(id).clear();
                break;
            case Devp:
                DEVP_EXCHANGE.get(id).clear();
                break;