#

Junjie

2025-01-12 5ad25a2233c76a5da8077a6862d5ddc3f94f5ad6

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

@@ -43,9 +43,9 @@
    @Autowired
    private WrkMastService wrkMastService;
    @Autowired
    private LocMastService locMastService;
    private WrkMastLogMapper wrkMastLogMapper;
    @Autowired
    private StaDescService staDescService;
    private LocMastService locMastService;
    @Autowired
    private BasDevpService basDevpService;
    @Autowired
@@ -54,6 +54,8 @@
    private BasLiftErrLogService basLiftErrLogService;
    @Autowired
    private BasShuttleErrService basShuttleErrService;
    @Autowired
    private BasLiftErrService basLiftErrService;
    @Autowired
    private CommonService commonService;
    @Autowired
@@ -64,8 +66,6 @@
    private ShuttleDispatchUtils shuttleDispatchUtils;
    @Autowired
    private RedisUtil redisUtil;
    @Autowired
    private WrkMastLogMapper wrkMastLogMapper;
    @Autowired
    private BasLiftOptService basLiftOptService;
    @Autowired
@@ -523,7 +523,7 @@
     */
    public synchronized void initRealtimeBasMap() {
        try {
            for (int i = 1; i <= 10; i++) {//总共四层楼
            for (int i = 1; i <= 4; i++) {//总共四层楼
                Object data = redisUtil.get(RedisKeyType.MAP.key + i);
                if (data == null) {//redis地图数据为空，从数据库中获取
                    BasMap basMap = basMapService.selectLatestMap(i);
@@ -819,28 +819,27 @@
//        return true;
//    }

//    /**
//     * 四向穿梭车任务完成
//     */
//    public synchronized void shuttleFinished() {
//        try {
//            for (ShuttleSlave shuttle : slaveProperties.getShuttle()) {
//                //获取四向穿梭车信息
//                NyShuttleThread shuttleThread = (NyShuttleThread) SlaveConnection.get(SlaveType.Shuttle, shuttle.getId());
//                NyShuttleProtocol shuttleProtocol = shuttleThread.getShuttleProtocol();
//                if (shuttleProtocol == null) {
//                    continue;
//                }
//
//                //四向穿梭车状态为等待确认、小车处于空闲状态
//                if (shuttleProtocol.getProtocolStatus() == ShuttleProtocolStatusType.WAITING.id  //任务完成等待确认
//                        && shuttleProtocol.getTaskNo() != 0
//                        && shuttleProtocol.getFree() == ShuttleStatusType.IDLE.id
//                ) {
//                    //将任务档标记为完成
//                    WrkMast wrkMast = wrkMastMapper.selectByWorkNo(shuttleProtocol.getTaskNo());
//                    if (wrkMast != null) {
//                        switch (wrkMast.getWrkSts().intValue()) {
    /**
     * 四向穿梭车任务完成
     */
    public synchronized void shuttleFinished() {
        try {
            for (ShuttleSlave shuttle : slaveProperties.getShuttle()) {
                //获取四向穿梭车信息
                ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, shuttle.getId());
                ShuttleProtocol shuttleProtocol = shuttleThread.getStatus();
                if (shuttleProtocol == null) {
                    continue;
                }

                //四向穿梭车状态为等待确认、小车处于空闲状态
                if (shuttleProtocol.getProtocolStatus() == ShuttleProtocolStatusType.WAITING.id  //任务完成等待确认
                        && shuttleProtocol.getTaskNo() != 0
                ) {
                    //将任务档标记为完成
                    WrkMast wrkMast = wrkMastService.selectByWorkNo(shuttleProtocol.getTaskNo());
                    if (wrkMast != null) {
                        switch (wrkMast.getWrkSts().intValue()) {
//                            case 5://5.小车搬运中 ==> 9.入库完成
//                                wrkMast.setWrkSts(9L);
//                                shuttleProtocol.setTaskNo(0);
@@ -857,78 +856,44 @@
//                                    shuttleProtocol.setToken(0);
//                                }
//                                break;
//                            case 102://102.小车移动至站点 ==> 103.小车移动至站点完成
//                                wrkMast.setWrkSts(103L);
//                                break;
//                            case 104://104.小车迁入提升机中 ==> 105.小车迁入提升机完成
//                                wrkMast.setWrkSts(105L);
//                                shuttleProtocol.setTaskNo(0);//清理工作号
//                                break;
//                            case 108://108.小车迁出提升机中 ==> 109.小车迁出提升机完成
//                                wrkMast.setWrkSts(109L);
//                                break;
//                            case 110://110.小车移动中 ==> 111.小车移动完成
//                                wrkMast.setWrkSts(111L);
//                                shuttleProtocol.setTaskNo(0);
//                                if (shuttleProtocol.getToken().equals(wrkMast.getWrkNo())) {
//                                    //释放小车令牌
//                                    shuttleProtocol.setToken(0);
//                                }
//                                break;
//                            default:
//                        }
//
//                        if (wrkMastMapper.updateById(wrkMast) > 0) {
//                            if (wrkMast.getWrkSts() == 111) {
//                                // 保存工作主档历史档
//                                if (wrkMastLogMapper.save(wrkMast.getWrkNo()) <= 0) {
//                                    log.info("保存工作历史档[workNo={0}]失败", wrkMast.getWrkNo());
//                                }
//                                // 删除工作主档
//                                if (!wrkMastService.deleteById(wrkMast)) {
//                                    log.info("删除工作主档[workNo={0}]失败", wrkMast.getWrkNo());
//                                }
//                            }
//
//                            //设置四向穿梭车为空闲状态
//                            shuttleProtocol.setProtocolStatus(ShuttleProtocolStatusType.IDLE);
//                            //源库位清零
//                            shuttleProtocol.setSourceLocNo(null);
//                            //目标库位清零
//                            shuttleProtocol.setLocNo(null);
//                            //任务指令清零
//                            shuttleProtocol.setAssignCommand(null);
//                            News.info("四向穿梭车已确认且任务完成状态,复位。四向穿梭车号={}", shuttleProtocol.getShuttleNo());
//                        } else {
//                            News.error("四向穿梭车已确认且任务完成状态,复位失败，但未找到工作档。四向穿梭车号={}，工作号={}", shuttleProtocol.getShuttleNo(), shuttleProtocol.getTaskNo());
//                        }
//                    } else {
//                        ShuttleAssignCommand assignCommand = shuttleProtocol.getAssignCommand();
//                        if (!assignCommand.getAuto()) {
//                            //手动模式
//                            //工作号清零
//                            shuttleProtocol.setTaskNo(0);
//                            //设置四向穿梭车为空闲状态
//                            shuttleProtocol.setProtocolStatus(ShuttleProtocolStatusType.IDLE);
//                            //源库位清零
//                            shuttleProtocol.setSourceLocNo(null);
//                            //目标库位清零
//                            shuttleProtocol.setLocNo(null);
//                            //任务指令清零
//                            shuttleProtocol.setAssignCommand(null);
//                            //清零令牌
//                            shuttleProtocol.setToken(0);
//                            News.info("四向穿梭车已确认且任务完成状态,复位。四向穿梭车号={}", shuttleProtocol.getShuttleNo());
//                        }
//                    }
//
//                }
//
//            }
//        } catch (Exception e) {
//            e.printStackTrace();
//        }
//    }
                            case 302://302.小车移动至站点 ==> 303.小车移动至站点完成
                                wrkMast.setWrkSts(WrkStsType.MOVE_SITE_COMPLETE.sts);
                                break;
                            case 110://310.小车移动中 ==> 311.小车移动完成
                                wrkMast.setWrkSts(WrkStsType.COMPLETE_MOVE.sts);
                                shuttleThread.setTaskNo(0);
                                break;
                            default:
                        }

                        if (wrkMastService.updateById(wrkMast)) {
                            //设置四向穿梭车为空闲状态
                            shuttleThread.setProtocolStatus(ShuttleProtocolStatusType.IDLE);
                            News.info("四向穿梭车已确认且任务完成状态,复位。四向穿梭车号={}", shuttleProtocol.getShuttleNo());
                        } else {
                            News.error("四向穿梭车已确认且任务完成状态,复位失败，但未找到工作档。四向穿梭车号={}，工作号={}", shuttleProtocol.getShuttleNo(), shuttleProtocol.getTaskNo());
                        }
                    } else {
                        Object object = redisUtil.get(RedisKeyType.SHUTTLE_WORK_FLAG.key + shuttleProtocol.getTaskNo());
                        if(object != null){
                            ShuttleAssignCommand assignCommand = JSON.parseObject(object.toString(), ShuttleAssignCommand.class);
                            if (!assignCommand.getAuto()) {
                                //手动模式
                                //工作号清零
                                shuttleThread.setTaskNo(0);
                                //设置四向穿梭车为空闲状态
                                shuttleThread.setProtocolStatus(ShuttleProtocolStatusType.IDLE);
                                News.info("四向穿梭车已确认且任务完成状态,复位。四向穿梭车号={}", shuttleProtocol.getShuttleNo());
                            }
                        }
                    }
                }

            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

//    /**
//     * 提升机任务
@@ -1253,37 +1218,27 @@
//        return true;
//    }
//
//    /**
//     * 提升机任务完成
//     */
//    public synchronized void liftFinished() {
//        try {
//            for (LiftSlave liftSlave : slaveProperties.getLift()) {
//                //获取提升机信息
//                LiftThread liftThread = (LiftThread) SlaveConnection.get(SlaveType.Lift, liftSlave.getId());
//                LiftProtocol liftProtocol = liftThread.getLiftProtocol();
//                if (liftProtocol == null) {
//                    continue;
//                }
//
//                //提升机为等待确认且空闲
//                if (liftProtocol.getProtocolStatus() == LiftProtocolStatusType.WAITING.id
//                        && liftProtocol.getTaskNo() != 0
//                        && !liftProtocol.getBusy()
//                ) {
//                    int taskNo = liftProtocol.getTaskNo().intValue();
//                    if (taskNo >= 20000 && taskNo <= 30000) {
//                        //提升机设备工作号，需要查询对应任务号
//                        BasLiftOpt basLiftOpt = basLiftOptService.selectByDeviceWrk(liftProtocol.getTaskNo().toString(), liftSlave.getId());
//                        if (basLiftOpt != null) {
//                            taskNo = basLiftOpt.getWrkNo();
//                        }
//                    }
//
//                    //将任务档标记为完成
//                    WrkMast wrkMast = wrkMastMapper.selectByWorkNo324104(taskNo);
//                    if (wrkMast != null) {
//                        switch (wrkMast.getWrkSts().intValue()) {
    /**
     * 货叉提升机任务完成
     */
    public synchronized void forkLiftFinished() {
        try {
            for (ForkLiftSlave forkLiftSlave : slaveProperties.getForkLift()) {
                //获取提升机信息
                ForkLiftThread forkLiftThread = (ForkLiftThread) SlaveConnection.get(SlaveType.ForkLift, forkLiftSlave.getId());
                ForkLiftProtocol forkLiftProtocol = forkLiftThread.getStatus();
                if (forkLiftProtocol == null) {
                    continue;
                }

                //提升机为等待确认且空闲
                if (forkLiftProtocol.getProtocolStatus() == ForkLiftProtocolStatusType.WAITING.id
                        && forkLiftProtocol.getWrkNo() != 0
                ) {
                    //将任务档标记为完成
                    WrkMast wrkMast = wrkMastService.selectByWorkNo(forkLiftProtocol.getWrkNo());
                    if (wrkMast != null) {
                        switch (wrkMast.getWrkSts().intValue()) {
//                            case 3://3.提升机搬运中 ==> 4.提升机搬运完成
//                                wrkMast.setWrkSts(4L);
//                                wrkMast.setLiftNo(null);//释放提升机
@@ -1305,263 +1260,186 @@
//                                        wrkMast.setModiTime(new Date());
//                                    }
//                                }
//
//                                if (liftProtocol.getToken().equals(wrkMast.getWrkNo())) {
//                                    //释放提升机令牌
//                                    liftProtocol.setToken(0);
//                                }
//
//                                break;
//                            case 106://106.提升机搬运中 ==> 107.提升机搬运完成
//                                wrkMast.setWrkSts(107L);
//                                break;
//                            default:
//                        }
//
//                        if (wrkMastMapper.updateById(wrkMast) > 0) {
//                            //设置提升机为空闲状态
//                            liftProtocol.setProtocolStatus(LiftProtocolStatusType.IDLE);
//                            //任务指令清零
//                            liftProtocol.setAssignCommand(null);
//                            News.info("提升机已确认且任务完成状态。提升机号={}", liftProtocol.getLiftNo());
//                        } else {
//                            News.error("提升机已确认且任务完成状态,复位失败，但未找到工作档。提升机号={}，工作号={}", liftProtocol.getLiftNo(), liftProtocol.getTaskNo());
//                        }
//                    } else {
//                        LiftAssignCommand assignCommand = liftProtocol.getAssignCommand();
//                        if (assignCommand != null) {
//                            if (!assignCommand.getAuto()) {
//                                //手动操作
//                                //设置提升机为空闲状态
//                                liftProtocol.setProtocolStatus(LiftProtocolStatusType.IDLE);
//                                //任务指令清零
//                                liftProtocol.setAssignCommand(null);
//                                News.info("提升机已确认手动操作。提升机号={}", liftProtocol.getLiftNo());
//                            }
//                        }
//                    }
//                }
//            }
//        } catch (Exception e) {
//            e.printStackTrace();
//        }
//    }
                            case 306://306.提升机搬运中 ==> 307.提升机搬运完成
                                wrkMast.setWrkSts(WrkStsType.MOVE_LIFT_RUN_COMPLETE.sts);
                                //货叉提升机需要跳过迁出提升机流程
                                wrkMast.setWrkSts(WrkStsType.MOVE_OUT_LIFT_COMPLETE.sts);
                                break;
                            default:
                        }

//    /**
//     * 异常信息记录
//     */
//    public void recErr() {
//        try {
//            this.recShuttleErr();
//            this.recLiftErr();
//        } catch (Exception e) {
//            News.error("recErr fail", e);
//        }
//    }
                        wrkMast.setModiTime(new Date());
                        if (wrkMastService.updateById(wrkMast)) {
                            forkLiftThread.reset();
                            News.info("提升机已确认且任务完成状态。提升机号={}", forkLiftProtocol.getLiftNo());
                        } else {
                            News.error("提升机已确认且任务完成状态,复位失败，但未找到工作档。提升机号={}，工作号={}", forkLiftProtocol.getLiftNo(), forkLiftProtocol.getWrkNo());
                        }
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

//    /**
//     * 四向穿梭车异常信息记录
//     */
//    private void recShuttleErr() {
//        Date now = new Date();
//        for (ShuttleSlave shuttleSlave : slaveProperties.getShuttle()) {
//            // 获取四向穿梭车信息
//            NyShuttleThread shuttleThread = (NyShuttleThread) SlaveConnection.get(SlaveType.Shuttle, shuttleSlave.getId());
//            if (shuttleThread == null) {
//                continue;
//            }
//            NyShuttleProtocol shuttleProtocol = shuttleThread.getShuttleProtocol();
//            if (shuttleProtocol == null) {
//                continue;
//            }
//
//            if (shuttleProtocol.getTaskNo() != 0) {
//                //有任务
//                BasShuttleErrLog latest = basShuttleErrLogService.findLatestByTaskNo(shuttleSlave.getId(), shuttleProtocol.getTaskNo());
//                // 有异常
//                if (latest == null) {
//                    if (shuttleProtocol.getErrState() != null && shuttleProtocol.getErrState() == 1) {
//                        WrkMast wrkMast = wrkMastMapper.selectById(shuttleProtocol.getTaskNo());
//                        if (wrkMast == null) {
//                            continue;
//                        }
//                        BasShuttleErr basShuttleErr = basShuttleErrService.queryByCode(shuttleProtocol.getErrCode());
//                        String errName = basShuttleErr==null? "未知异常":basShuttleErr.getErrName();
//                        BasShuttleErrLog basShuttleErrLog = new BasShuttleErrLog(
//                                null,    // 编号
//                                wrkMast.getWrkNo(),    // 工作号
//                                now,    // 发生时间
//                                null,    // 结束时间
//                                wrkMast.getWrkSts(),    // 工作状态
//                                wrkMast.getIoType(),    // 入出库类型
//                                shuttleSlave.getId(),    // 四向穿梭车
//                                null,    // plc
//                                wrkMast.getLocNo(),    // 目标库位
//                                wrkMast.getStaNo(),    // 目标站
//                                wrkMast.getSourceStaNo(),    // 源站
//                                wrkMast.getSourceLocNo(),    // 源库位
//                                wrkMast.getBarcode(),    // 条码
//                                shuttleProtocol.getErrCode(),    // 异常码
//                                errName,    // 异常
//                                1,    // 异常情况
//                                now,    // 添加时间
//                                null,    // 添加人员
//                                now,    // 修改时间
//                                null,    // 修改人员
//                                "任务中异常",    // 备注
//                                JSON.toJSONString(shuttleProtocol)    // 系统状态数据
//                        );
//                        if (!basShuttleErrLogService.insert(basShuttleErrLog)) {
//                            News.error("四向穿梭车plc异常记录失败 ===>> [id:{}] [error:{}]", shuttleSlave.getId(), errName);
//                        }
//                    }
//                } else {
//                    // 异常修复
//                    if (shuttleProtocol.getErrState() == null || shuttleProtocol.getErrState() == 0) {
//                        latest.setEndTime(now);
//                        latest.setUpdateTime(now);
//                        latest.setStatus(2);
//                        if (!basShuttleErrLogService.updateById(latest)) {
//                            News.error("四向穿梭车plc异常记录修复失败 ===>> [id:{}] [errLogId:{}]", shuttleSlave.getId(), latest.getId());
//                        }
//                    }
//                }
//            }else {
////                //无任务
////                BasShuttleErrLog latest = basShuttleErrLogService.findLatest(shuttleSlave.getId());
////                // 有异常
////                if (shuttleProtocol.getStatusErrorCode() != null && shuttleProtocol.getStatusErrorCode() > 0) {
////                    // 记录新异常
////                    if (latest == null || (latest.getErrCode() != shuttleProtocol.getStatusErrorCode().intValue())) {
////                        BasShuttleErr basShuttleErr = basShuttleErrService.queryByCode(shuttleProtocol.getStatusErrorCode().intValue());
////                        String errName = basShuttleErr==null? "未知异常":basShuttleErr.getErrName();
////                        BasShuttleErrLog basShuttleErrLog = new BasShuttleErrLog(
////                                null,    // 编号
////                                null,    // 工作号
////                                now,    // 发生时间
////                                null,    // 结束时间
////                                null,    // 工作状态
////                                null,    // 入出库类型
////                                shuttleSlave.getId(),    // 四向穿梭车
////                                null,    // plc
////                                null,    // 目标库位
////                                null,    // 目标站
////                                null,    // 源站
////                                null,    // 源库位
////                                null,    // 条码
////                                (int)shuttleProtocol.getStatusErrorCode(),    // 异常码
////                                errName,    // 异常
////                                1,    // 异常情况
////                                now,    // 添加时间
////                                null,    // 添加人员
////                                now,    // 修改时间
////                                null,    // 修改人员
////                                "无任务异常"    // 备注
////                        );
////                        if (!basShuttleErrLogService.insert(basShuttleErrLog)) {
////                            News.error("四向穿梭车plc异常记录失败 ===>> [id:{}] [error:{}]", shuttleSlave.getId(), errName);
////                        }
////                    }
////                    // 无异常
////                } else {
////                    // 异常修复
////                    if (latest != null && latest.getStatus() == 1) {
////                        latest.setEndTime(now);
////                        latest.setUpdateTime(now);
////                        latest.setStatus(2);
////                        if (!basShuttleErrLogService.updateById(latest)) {
////                            News.error("四向穿梭车plc异常记录修复失败 ===>> [id:{}] [errLogId:{}]", shuttleSlave.getId(), latest.getId());
////                        }
////                    }
////                }
//            }
//        }
//    }
//
//    /**
//     * 提升机异常信息记录
//     */
//    private void recLiftErr() {
//        Date now = new Date();
//        for (LiftSlave liftSlave : slaveProperties.getLift()) {
//            // 获取提升机信息
//            LiftThread liftThread = (LiftThread) SlaveConnection.get(SlaveType.Lift, liftSlave.getId());
//            if (liftThread == null) {
//                continue;
//            }
//            LiftProtocol liftProtocol = liftThread.getLiftProtocol();
//            if (liftProtocol == null) {
//                continue;
//            }
//
//            if (liftProtocol.getTaskNo() != 0) {
//                //有任务
//                BasLiftErrLog latest = basLiftErrLogService.findLatestByTaskNo(liftSlave.getId(), liftProtocol.getTaskNo().intValue());
//                // 有异常
//                if (latest == null) {
//                    if (liftProtocol.getDeviceError() != null && liftProtocol.getDeviceError()) {
//                        WrkMast wrkMast = wrkMastMapper.selectById(liftProtocol.getTaskNo());
//                        if (wrkMast == null) {
//                            continue;
//                        }
//
//                        String errName = "";
//                        if (liftProtocol.getFrontOverrun()) {
//                            errName = "前超限";
//                        } else if (liftProtocol.getBackOverrun()) {
//                            errName = "后超限";
//                        } else if (liftProtocol.getLeftOverrun()) {
//                            errName = "左超限";
//                        } else if (liftProtocol.getRightOverrun()) {
//                            errName = "右超限";
//                        } else if (liftProtocol.getOverHeight()) {
//                            errName = "超高";
//                        } else if (liftProtocol.getOverWeight()) {
//                            errName = "超重";
//                        }
//
//                        BasLiftErrLog basLiftErrLog = new BasLiftErrLog(
//                                null,    // 编号
//                                wrkMast.getWrkNo(),    // 工作号
//                                now,    // 发生时间
//                                null,    // 结束时间
//                                wrkMast.getWrkSts(),    // 工作状态
//                                wrkMast.getIoType(),    // 入出库类型
//                                liftSlave.getId(),    // 提升机
//                                null,    // plc
//                                wrkMast.getLocNo(),    // 目标库位
//                                wrkMast.getStaNo(),    // 目标站
//                                wrkMast.getSourceStaNo(),    // 源站
//                                wrkMast.getSourceLocNo(),    // 源库位
//                                wrkMast.getBarcode(),    // 条码
//                                null,    // 异常码
//                                errName,    // 异常
//                                1,    // 异常情况
//                                now,    // 添加时间
//                                null,    // 添加人员
//                                now,    // 修改时间
//                                null,    // 修改人员
//                                "任务中异常",    // 备注
//                                JSON.toJSONString(liftProtocol)    // 系统状态数据
//                        );
//                        if (!basLiftErrLogService.insert(basLiftErrLog)) {
//                            News.error("提升机plc异常记录失败 ===>> [id:{}] [error:{}]", liftSlave.getId(), errName);
//                        }
//                    }
//                } else {
//                    // 异常修复
//                    if (liftProtocol.getDeviceError() == null || !liftProtocol.getDeviceError()) {
//                        latest.setEndTime(now);
//                        latest.setUpdateTime(now);
//                        latest.setStatus(2);
//                        if (!basLiftErrLogService.updateById(latest)) {
//                            News.error("提升机plc异常记录修复失败 ===>> [id:{}] [errLogId:{}]", liftSlave.getId(), latest.getId());
//                        }
//                    }
//                }
//            }
//        }
//    }
    /**
     * 异常信息记录
     */
    public void recErr() {
        try {
            this.recShuttleErr();
            this.recLiftErr();
        } catch (Exception e) {
            News.error("recErr fail", e);
        }
    }

    /**
     * 四向穿梭车异常信息记录
     */
    private void recShuttleErr() {
        Date now = new Date();
        for (ShuttleSlave shuttleSlave : slaveProperties.getShuttle()) {
            // 获取四向穿梭车信息
            ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, shuttleSlave.getId());
            if (shuttleThread == null) {
                continue;
            }
            ShuttleProtocol shuttleProtocol = shuttleThread.getStatus();
            if (shuttleProtocol == null) {
                continue;
            }

            if (shuttleProtocol.getTaskNo() != 0) {
                //有任务
                BasShuttleErrLog latest = basShuttleErrLogService.findLatestByTaskNo(shuttleSlave.getId(), shuttleProtocol.getTaskNo());
                // 有异常
                if (latest == null) {
                    if (shuttleProtocol.getErrorCode() != null && Integer.parseInt(shuttleProtocol.getErrorCode()) != 0) {
                        WrkMast wrkMast = wrkMastService.selectByWorkNo(shuttleProtocol.getTaskNo());
                        if (wrkMast == null) {
                            continue;
                        }
                        int errorCode = Integer.parseInt(shuttleProtocol.getErrorCode());
                        BasShuttleErr basShuttleErr = basShuttleErrService.queryByCode(errorCode);
                        String errName = basShuttleErr==null? "未知异常":basShuttleErr.getErrName();
                        BasShuttleErrLog basShuttleErrLog = new BasShuttleErrLog(
                                null,    // 编号
                                wrkMast.getWrkNo(),    // 工作号
                                now,    // 发生时间
                                null,    // 结束时间
                                wrkMast.getWrkSts(),    // 工作状态
                                wrkMast.getIoType(),    // 入出库类型
                                shuttleSlave.getId(),    // 四向穿梭车
                                null,    // plc
                                wrkMast.getLocNo(),    // 目标库位
                                wrkMast.getStaNo(),    // 目标站
                                wrkMast.getSourceStaNo(),    // 源站
                                wrkMast.getSourceLocNo(),    // 源库位
                                wrkMast.getBarcode(),    // 条码
                                errorCode,    // 异常码
                                errName,    // 异常
                                1,    // 异常情况
                                now,    // 添加时间
                                null,    // 添加人员
                                now,    // 修改时间
                                null,    // 修改人员
                                "任务中异常",    // 备注
                                JSON.toJSONString(shuttleProtocol)    // 系统状态数据
                        );
                        if (!basShuttleErrLogService.insert(basShuttleErrLog)) {
                            News.error("四向穿梭车plc异常记录失败 ===>> [id:{}] [error:{}]", shuttleSlave.getId(), errName);
                        }
                    }
                } else {
                    // 异常修复
                    if (shuttleProtocol.getErrorCode() == null || Integer.parseInt(shuttleProtocol.getErrorCode()) == 0) {
                        latest.setEndTime(now);
                        latest.setUpdateTime(now);
                        latest.setStatus(2);
                        if (!basShuttleErrLogService.updateById(latest)) {
                            News.error("四向穿梭车plc异常记录修复失败 ===>> [id:{}] [errLogId:{}]", shuttleSlave.getId(), latest.getId());
                        }
                    }
                }
            }
        }
    }

    /**
     * 提升机异常信息记录
     */
    private void recLiftErr() {
        Date now = new Date();
        for (ForkLiftSlave forkLiftSlave : slaveProperties.getForkLift()) {
            // 获取提升机信息
            ForkLiftThread forkLiftThread = (ForkLiftThread) SlaveConnection.get(SlaveType.ForkLift, forkLiftSlave.getId());
            if (forkLiftThread == null) {
                continue;
            }
            ForkLiftProtocol forkLiftProtocol = forkLiftThread.getStatus();
            if (forkLiftProtocol == null) {
                continue;
            }

            if (forkLiftProtocol.getTaskNo() != 0) {
                //有任务
                BasLiftErrLog latest = basLiftErrLogService.findLatestByTaskNo(forkLiftSlave.getId(), forkLiftProtocol.getTaskNo());
                // 有异常
                if (latest == null) {
                    if (forkLiftProtocol.getErrorCode() != null && forkLiftProtocol.getErrorCode() != 0) {
                        WrkMast wrkMast = wrkMastService.selectByWorkNo(forkLiftProtocol.getWrkNo());
                        if (wrkMast == null) {
                            continue;
                        }

                        BasLiftErr basLiftErr = basLiftErrService.queryByCode(forkLiftProtocol.getErrorCode());
                        String errName = basLiftErr==null? "未知异常":basLiftErr.getErrName();

                        BasLiftErrLog basLiftErrLog = new BasLiftErrLog(
                                null,    // 编号
                                wrkMast.getWrkNo(),    // 工作号
                                now,    // 发生时间
                                null,    // 结束时间
                                wrkMast.getWrkSts(),    // 工作状态
                                wrkMast.getIoType(),    // 入出库类型
                                forkLiftSlave.getId(),    // 提升机
                                null,    // plc
                                wrkMast.getLocNo(),    // 目标库位
                                wrkMast.getStaNo(),    // 目标站
                                wrkMast.getSourceStaNo(),    // 源站
                                wrkMast.getSourceLocNo(),    // 源库位
                                wrkMast.getBarcode(),    // 条码
                                null,    // 异常码
                                errName,    // 异常
                                1,    // 异常情况
                                now,    // 添加时间
                                null,    // 添加人员
                                now,    // 修改时间
                                null,    // 修改人员
                                "任务中异常",    // 备注
                                JSON.toJSONString(forkLiftProtocol)    // 系统状态数据
                        );
                        if (!basLiftErrLogService.insert(basLiftErrLog)) {
                            News.error("提升机plc异常记录失败 ===>> [id:{}] [error:{}]", forkLiftSlave.getId(), errName);
                        }
                    }
                } else {
                    // 异常修复
                    if (forkLiftProtocol.getErrorCode() == null || forkLiftProtocol.getErrorCode() == 0) {
                        latest.setEndTime(now);
                        latest.setUpdateTime(now);
                        latest.setStatus(2);
                        if (!basLiftErrLogService.updateById(latest)) {
                            News.error("提升机plc异常记录修复失败 ===>> [id:{}] [errLogId:{}]", forkLiftSlave.getId(), latest.getId());
                        }
                    }
                }
            }
        }
    }

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

@@ -1864,220 +1742,310 @@
//        }
    }

//    /**
//     * 四向穿梭车电量检测 ===>> 发起充电
//     */
//    public synchronized void loopShuttleCharge() {
//        try {
//            for (ShuttleSlave shuttle : slaveProperties.getShuttle()) {
//                //获取四向穿梭车线程
//                NyShuttleThread shuttleThread = (NyShuttleThread) SlaveConnection.get(SlaveType.Shuttle, shuttle.getId());
//                NyShuttleProtocol shuttleProtocol = shuttleThread.getShuttleProtocol();
//                if (shuttleProtocol == null) {
//                    continue;
//                }
//
//                //判断当前小车是否满足需要充电要求
//                if (!shuttleProtocol.isRequireCharge()) {
//                    continue;
//                }
//
//                WrkCharge wrkCharge = wrkChargeService.selectWorking(shuttleProtocol.getShuttleNo().intValue());
//                if (wrkCharge != null) {//已有充电任务
//                    continue;
//                }
//
//                //小车所在楼层
//                int lev = Utils.getLev(shuttleProtocol.getCurrentLocNo());
//                ShuttleChargeType shuttleCharge = null;
//
//                //搜索小车所在楼层有没有充电桩
//                for (ShuttleChargeType chargeType : ShuttleChargeType.values()) {
//                    if (lev != Utils.getLev(chargeType.locNo)) {
//                        continue;//小车和充电桩不在同一层
//                    }
//
//                    //小车和充电桩在同一层
//                    if (wrkChargeService.selectWorkingOfCharge(chargeType.id) == null) {
//                        shuttleCharge = chargeType;
//                        break;
//                    }
//                }
//
//                if (shuttleCharge == null) {
//                    //同楼层没有找到充电桩，找可用充电桩
//                    //小车同楼层没有充电桩，只要充电桩可用就生成充电任务
//                    for (ShuttleChargeType chargeType : ShuttleChargeType.values()) {
//                        if (wrkChargeService.selectWorkingOfCharge(chargeType.id) == null) {
//                            //判断当前充电桩楼层是否有小车，如有小车，不分配该充电桩
//                            int chargeLev = Utils.getLev(chargeType.locNo);//充电桩楼层
//                            boolean checkLevHasShuttle = Utils.checkLevHasShuttle(chargeLev);//检测楼层是否有穿梭车
//                            if (checkLevHasShuttle) {
//                                //当前充电桩楼层有穿梭车，不分配该充电桩
//                                continue;
//                            }
//
//                            shuttleCharge = chargeType;
//                            break;
//                        }
//                    }
//                }
//
//                if (shuttleCharge == null) {
//                    continue;
//                }
//
//                String chargeLocNo = shuttleCharge.locNo;
//                wrkCharge = new WrkCharge();
//                wrkCharge.setShuttleNo(shuttle.getId());
//                wrkCharge.setCharge(shuttleCharge.id);
//                wrkCharge.setWrkNo(commonService.getChargeWorkNo(4));
//                wrkCharge.setWrkSts(51L);   // 51.准备充电
//                wrkCharge.setIoPri((double) 10);
//                wrkCharge.setLocNo(chargeLocNo);
//                wrkCharge.setMemo("charge");
//                wrkCharge.setAppeTime(new Date());
//                if (!wrkChargeService.insert(wrkCharge)) {
//                    News.error("保存{}号四向穿梭车充电任务失败!!!", shuttle.getId());
//                    continue;
//                }
//
//                News.info("保存{}号四向穿梭车充电任务成功!!!", shuttle.getId());
//            }
//        } catch (Exception e) {
//            e.printStackTrace();
//        }
//    }
//
//    /**
//     * 执行四向穿梭车充电任务
//     */
//    public synchronized void executeShuttleCharge() {
//        try {
//            for (ShuttleSlave shuttle : slaveProperties.getShuttle()) {
//                WrkCharge wrkCharge = wrkChargeService.selectWorking(shuttle.getId());
//                if (wrkCharge == null) {
//                    continue;
//                }
//
//                NyShuttleThread shuttleThread = (NyShuttleThread) SlaveConnection.get(SlaveType.Shuttle, wrkCharge.getShuttleNo());
//                if (shuttleThread == null) {
//                    continue;
//                }
//                NyShuttleProtocol shuttleProtocol = shuttleThread.getShuttleProtocol();
//                if (shuttleProtocol == null) {
//                    continue;
//                }
//
//                if (wrkCharge.getWrkSts() == 51) {
//                    if (!shuttleProtocol.isIdleNoCharge()) {
//                        continue;
//                    }
//
//                    if (shuttleProtocol.getSuspendState() == 1) {
//                        continue;//管制中
//                    }
//
//                    if (!shuttleProtocol.getCurrentLocNo().equals(wrkCharge.getLocNo())) {
//                        //小车不在充电桩位置
//                        shuttleDispatchUtils.dispatchShuttle(wrkCharge.getWrkNo(), wrkCharge.getLocNo(), shuttle.getId());//调度小车去充电桩
//                        continue;
//                    }
//
//                    //小车已经在充电桩位置，下发充电命令
//                    NyShuttleHttpCommand chargeCommand = NyHttpUtils.getChargeCommand(shuttle.getId(), wrkCharge.getWrkNo(), true);
//                    ArrayList<NyShuttleHttpCommand> commands = new ArrayList<>();
//                    commands.add(chargeCommand);
//                    //创建分配命令
//                    ShuttleAssignCommand assignCommand = new ShuttleAssignCommand();
//                    assignCommand.setShuttleNo(shuttleProtocol.getShuttleNo());//四向穿梭车号
//                    assignCommand.setTaskNo(wrkCharge.getWrkNo().shortValue());//任务号
//                    assignCommand.setTaskMode(ShuttleTaskModeType.CHARGE.id.shortValue());//出库模式
//                    assignCommand.setSourceLocNo(shuttleProtocol.getCurrentLocNo());//源库位(小车当前位置)
//                    assignCommand.setCommands(commands);//运行命令
//
//                    wrkCharge.setWrkSts(52L);//51.生成充电任务 => 52.小车去充电中
//                    wrkCharge.setModiTime(new Date());
//                    if (wrkChargeMapper.updateById(wrkCharge) > 0) {
//                        //下发任务
//                        MessageQueue.offer(SlaveType.Shuttle, assignCommand.getShuttleNo().intValue(), new Task(3, assignCommand));
//                    }
//                } else if (wrkCharge.getWrkSts() == 52) {
//                    //检测小车是否满电
//
//                    //获取满电阈值
//                    int maxPower = 95;
//                    EntityWrapper<Config> wrapper = new EntityWrapper<>();
//                    wrapper.eq("code", "chargeMaxValue");
//                    Config config = configService.selectOne(wrapper);
//                    if (config != null) {
//                        maxPower = Integer.parseInt(config.getValue());
//                    }
//
//                    if (shuttleProtocol.getPowerPercent() < maxPower) {
//                        continue;
//                    }
//
//                    //***************判断是否满充校准***************
//                    EntityWrapper<Config> wrapper1 = new EntityWrapper<>();
//                    wrapper.eq("code", "shuttleMaxPowerVerify");
//                    Config config1 = configService.selectOne(wrapper1);
//                    if (config1 != null) {
//                        if (config1.getValue().equals("true")) {
//                            if (shuttleProtocol.getVoltage() < 5630) {
//                                continue;//电压不够继续充电
//                            }
//                        }
//                    }
//                    //***************判断是否满充校准***************
//
//                    //小车满电，结束充电任务
//                    NyShuttleHttpCommand chargeCommand = NyHttpUtils.getChargeCommand(shuttle.getId(), wrkCharge.getWrkNo(), false);
//                    ArrayList<NyShuttleHttpCommand> commands = new ArrayList<>();
//                    commands.add(chargeCommand);
//                    //创建分配命令
//                    ShuttleAssignCommand assignCommand = new ShuttleAssignCommand();
//                    assignCommand.setShuttleNo(shuttleProtocol.getShuttleNo());//四向穿梭车号
//                    assignCommand.setTaskNo(wrkCharge.getWrkNo().shortValue());//任务号
//                    assignCommand.setTaskMode(ShuttleTaskModeType.CHARGE.id.shortValue());//出库模式
//                    assignCommand.setSourceLocNo(shuttleProtocol.getCurrentLocNo());//源库位(小车当前位置)
//                    assignCommand.setCommands(commands);//运行命令
//
//                    //下发任务
//                    MessageQueue.offer(SlaveType.Shuttle, assignCommand.getShuttleNo().intValue(), new Task(3, assignCommand));
//                    try {
//                        Thread.sleep(3000);
//                    } catch (Exception e) {
//                        e.printStackTrace();
//                    }
//
//                    wrkCharge.setWrkSts(53L);//52.小车去充电中 => 53.小车充电完成
//                    wrkCharge.setModiTime(new Date());
//                    if (wrkChargeMapper.updateById(wrkCharge) > 0) {
//                        shuttleProtocol.setProtocolStatus(ShuttleProtocolStatusType.IDLE.id);
//                        shuttleProtocol.setTaskNo(0);
//                        shuttleProtocol.setPakMk(false);
//                    }
//                } else if (wrkCharge.getWrkSts() == 53) {
//                    if (shuttleProtocol.getChargState() == 0) {//小车处于未充电状态
//                        boolean result = Utils.searchEmptyGroupToMoveShuttle(Utils.getLev(wrkCharge.getLocNo()), shuttleThread.getSlave().getId(), shuttleThread);
//                        if (!result) {
//                            continue;
//                        }
//
//                        wrkCharge.setWrkSts(60L);//53.小车充电完成 => 60.充电任务完成
//                        wrkCharge.setModiTime(new Date());
//                        if (wrkChargeMapper.updateById(wrkCharge) > 0) {
//
//                        }
//                    }
//                }
//
//            }
//        } catch (Exception e) {
//            e.printStackTrace();
//        }
//    }
    /**
     * 四向穿梭车电量检测 ===>> 发起充电
     */
    public synchronized void loopShuttleCharge() {
        try {
            for (ShuttleSlave shuttle : slaveProperties.getShuttle()) {
                //获取四向穿梭车线程
                ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, shuttle.getId());
                ShuttleProtocol shuttleProtocol = shuttleThread.getStatus();
                if (shuttleProtocol == null) {
                    continue;
                }

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

                WrkMast wrkMast = wrkMastService.selectChargeWorking(shuttleProtocol.getShuttleNo());
                if (wrkMast != null) {//已有充电任务
                    continue;
                }

                //小车所在楼层
                int lev = Utils.getLev(shuttleProtocol.getCurrentLocNo());
                ShuttleChargeType shuttleCharge = null;

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

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

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

                            shuttleCharge = chargeType;
                            break;
                        }
                    }
                }

                if (shuttleCharge == null) {
                    continue;
                }

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

                News.info("保存{}号四向穿梭车充电任务成功!!!", shuttle.getId());
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 执行四向穿梭车充电任务
     */
    public synchronized void executeShuttleCharge() {
        try {
            //查询小车移库任务
            for (ShuttleSlave shuttle : slaveProperties.getShuttle()) {
                WrkMast wrkMast = wrkMastService.selectChargeWorking(shuttle.getId());
                if(wrkMast == null) {
                    continue;
                }

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

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

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

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

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

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

            if (shuttleProtocol.getCurrentLocNo().equals(wrkMast.getLocNo())) {
                //小车在充电桩位置
                wrkMast.setWrkSts(WrkStsType.CHARGE_SHUTTLE_RUN_COMPLETE.sts);
                wrkMast.setModiTime(new Date());
                wrkMastService.updateById(wrkMast);
                return false;
            }

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

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

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

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

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

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

            return false;
        }
        return true;
    }

    //小车开始充电
    private synchronized boolean executeShuttleChargeStepStartCharge(WrkMast wrkMast) {
        if (wrkMast.getWrkSts() == WrkStsType.CHARGE_SHUTTLE_RUN_COMPLETE.sts) {
            ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, wrkMast.getShuttleNo());
            if (shuttleThread == null) {
                return false;
            }
            ShuttleProtocol shuttleProtocol = shuttleThread.getStatus();
            if (shuttleProtocol == null) {
                return false;
            }

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

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

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

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

    //小车停止充电
    private synchronized boolean executeShuttleChargeStepStopCharge(WrkMast wrkMast) {
        if (wrkMast.getWrkSts() == WrkStsType.CHARGE_SHUTTLE_WORKING.sts) {
            ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, wrkMast.getShuttleNo());
            if (shuttleThread == null) {
                return false;
            }
            ShuttleProtocol shuttleProtocol = shuttleThread.getStatus();
            if (shuttleProtocol == null) {
                return false;
            }

            if (!shuttleThread.isChargingCompleted()) {
                return false;
            }

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

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

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

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

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

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

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

            return false;
        }
        return true;
    }

    /**
     * 执行小车移库任务
@@ -2304,17 +2272,6 @@
                wrkMast.setLiftNo(null);//释放提升机
                wrkMast.setModiTime(now);
                wrkMastService.updateById(wrkMast);

                if (wrkMast.getWrkSts() == WrkStsType.COMPLETE_MOVE.sts) {
                    // 保存工作主档历史档
                    if (wrkMastLogMapper.save(wrkMast.getWrkNo()) <= 0) {
                        log.info("保存工作历史档[workNo={}]失败", wrkMast.getWrkNo());
                    }
                    // 删除工作主档
                    if (!wrkMastService.deleteById(wrkMast)) {
                        log.info("删除工作主档[workNo={}]失败", wrkMast.getWrkNo());
                    }
                }
                return false;
            }