#

Junjie

2025-02-11 ed265ddfb8f08f69af064a9adf65fcbf06289ffe

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

@@ -1,9 +1,12 @@
package com.zy.asrs.service.impl;

import com.alibaba.fastjson.JSON;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.zy.asrs.domain.enums.NotifyMsgType;
import com.zy.asrs.entity.*;
import com.zy.asrs.mapper.*;
import com.zy.asrs.service.*;
import com.zy.asrs.utils.NotifyUtils;
import com.zy.asrs.utils.Utils;
import com.zy.common.model.*;
import com.zy.common.model.enums.NavigationMapType;
@@ -55,6 +58,8 @@
    @Autowired
    private BasShuttleErrService basShuttleErrService;
    @Autowired
    private BasLiftErrService basLiftErrService;
    @Autowired
    private CommonService commonService;
    @Autowired
    private BasMapService basMapService;
@@ -80,6 +85,8 @@
    private ShuttleAction shuttleAction;
    @Autowired
    private ForkLiftAction forkLiftAction;
    @Autowired
    private NotifyUtils notifyUtils;


//    /**
@@ -837,45 +844,60 @@
                    //将任务档标记为完成
                    WrkMast wrkMast = wrkMastService.selectByWorkNo(shuttleProtocol.getTaskNo());
                    if (wrkMast != null) {
                        switch (wrkMast.getWrkSts().intValue()) {
//                            case 5://5.小车搬运中 ==> 9.入库完成
//                                wrkMast.setWrkSts(9L);
//                                shuttleProtocol.setTaskNo(0);
//                                if (shuttleProtocol.getToken().equals(wrkMast.getWrkNo())) {
//                                    //释放小车令牌
//                                    shuttleProtocol.setToken(0);
//                                }
//                                break;
//                            case 22://22.小车搬运中 ==> 23.小车搬运完成
//                                wrkMast.setWrkSts(23L);
//                                shuttleProtocol.setTaskNo(0);
//                                if (shuttleProtocol.getToken().equals(wrkMast.getWrkNo())) {
//                                    //释放小车令牌
//                                    shuttleProtocol.setToken(0);
//                                }
//                                break;
                            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 (wrkMast.getWrkSts() == WrkStsType.MOVE_SITE.sts) {
                            //302.小车移动至站点 ==> 303.小车移动至站点完成
                            wrkMast.setWrkSts(WrkStsType.MOVE_SITE_COMPLETE.sts);
                            shuttleThread.setSyncTaskNo(0);
                        } else if (wrkMast.getWrkSts() == WrkStsType.MOVE_OUT_LIFT.sts) {
                            //308.小车迁出提升机中 ==> 309.小车迁出提升机完成
                            wrkMast.setWrkSts(WrkStsType.MOVE_OUT_LIFT_COMPLETE.sts);
                            shuttleThread.setSyncTaskNo(0);
                        } else if (wrkMast.getWrkSts() == WrkStsType.MOVE_SHUTTLE.sts) {
                            //310.小车移动中 ==> 311.小车移动完成
                            wrkMast.setWrkSts(WrkStsType.COMPLETE_MOVE.sts);
                            shuttleThread.setSyncTaskNo(0);
                            notifyUtils.notify(String.valueOf(SlaveType.Shuttle), shuttleProtocol.getShuttleNo(), String.valueOf(wrkMast.getWrkNo()), NotifyMsgType.SHUTTLE_MOVE_COMPLETE);//触发通知
                        } else if (wrkMast.getWrkSts() == WrkStsType.CHARGE_SHUTTLE_WORKING.sts) {
                            //204.小车充电中 ==> 205.小车充电完成
                            wrkMast.setWrkSts(WrkStsType.CHARGE_SHUTTLE_COMPLETE.sts);
                            shuttleThread.setSyncTaskNo(0);
                            notifyUtils.notify(String.valueOf(SlaveType.Shuttle), shuttleProtocol.getShuttleNo(), String.valueOf(wrkMast.getWrkNo()), NotifyMsgType.SHUTTLE_POWER_COMPLETE);//触发通知
                        } else if (wrkMast.getWrkSts() == WrkStsType.LOC_MOVE_SHUTTLE_RUN.sts) {
                            //502.小车搬运中 ==> 509.移库完成
                            wrkMast.setWrkSts(WrkStsType.COMPLETE_LOC_MOVE.sts);
                            shuttleThread.setSyncTaskNo(0);
                            notifyUtils.notify(String.valueOf(SlaveType.Shuttle), shuttleProtocol.getShuttleNo(), String.valueOf(wrkMast.getWrkNo()), NotifyMsgType.SHUTTLE_DELIVERY);//触发通知
                        } else {
                            continue;
                        }
//                        switch (wrkMast.getWrkSts().intValue()) {
////                            case 5://5.小车搬运中 ==> 9.入库完成
////                                wrkMast.setWrkSts(9L);
////                                shuttleProtocol.setTaskNo(0);
////                                if (shuttleProtocol.getToken().equals(wrkMast.getWrkNo())) {
////                                    //释放小车令牌
////                                    shuttleProtocol.setToken(0);
////                                }
////                                break;
////                            case 22://22.小车搬运中 ==> 23.小车搬运完成
////                                wrkMast.setWrkSts(23L);
////                                shuttleProtocol.setTaskNo(0);
////                                if (shuttleProtocol.getToken().equals(wrkMast.getWrkNo())) {
////                                    //释放小车令牌
////                                    shuttleProtocol.setToken(0);
////                                }
////                                break;
//                            case 302:
//                                wrkMast.setWrkSts(WrkStsType.MOVE_SITE_COMPLETE.sts);
//                                break;
//                            case WrkStsType.MOVE_SHUTTLE.sts:
//                                wrkMast.setWrkSts(WrkStsType.COMPLETE_MOVE.sts);
//                                shuttleThread.setSyncTaskNo(0);
//                                break;
//                            default:
//                        }

                        if (wrkMastService.updateById(wrkMast)) {
                            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());
                                }
                            }

                            //设置四向穿梭车为空闲状态
                            shuttleThread.setProtocolStatus(ShuttleProtocolStatusType.IDLE);
                            News.info("四向穿梭车已确认且任务完成状态,复位。四向穿梭车号={}", shuttleProtocol.getShuttleNo());
@@ -902,6 +924,101 @@
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 执行移库任务
     */
    public synchronized void shuttleLocMoveExecute() {
        try {
            //查询移库任务
            List<WrkMast> wrkMasts = wrkMastService.selectList(new EntityWrapper<WrkMast>().in("wrk_sts", WrkStsType.NEW_LOC_MOVE.sts));
            for (WrkMast wrkMast : wrkMasts) {
                boolean stepToTarget = this.shuttleLocMoveExecuteToTarget(wrkMast);//移库任务-小车去目标点
                if (!stepToTarget) {
                    continue;
                }

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

    /**
     * 移库任务-小车去目标点
     * 如需主方法执行continue，请返回false
     * ps:返回值true并不代表该方法执行成功，返回值仅做标记用于主方法是否执行continue
     */
    private boolean shuttleLocMoveExecuteToTarget(WrkMast wrkMast) {
        //--------------------------------------小车移动至站点-----------------------------------------//
        Date now = new Date();

        //小车移动至站点  501.生成移库任务 ==> 502.小车搬运中
        if (wrkMast.getWrkSts() == WrkStsType.NEW_LOC_MOVE.sts) {
            if (wrkMast.getShuttleNo() == null) {//没有绑定小车，进行调度
                boolean result = shuttleDispatchUtils.dispatchShuttle(wrkMast.getWrkNo(), wrkMast.getSourceLocNo());//调度小车到货物点进行取货
                News.info("{}任务，调度小车{}系统等待中", wrkMast.getWrkNo(), result ? "成功" : "失败");
                return false;
            }

            //获取四向穿梭车线程
            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.getSourceLocNo())) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，小车未到达取货位置", wrkMast.getWrkNo(), wrkMast.getSourceLocNo());
                return false;
            }

            ShuttleAssignCommand assignCommand = new ShuttleAssignCommand();
            assignCommand.setShuttleNo(shuttleProtocol.getShuttleNo()); // 四向穿梭车编号
            assignCommand.setTaskMode(ShuttleTaskModeType.TRANSPORT.id);//小车移库任务
            assignCommand.setTaskNo(wrkMast.getWrkNo());//任务号
            assignCommand.setAuto(true);//自动模式

            //获取小车到输送站点行走命令
            List<ShuttleCommand> commands = shuttleOperaUtils.getStartToTargetCommands(wrkMast.getSourceLocNo(), wrkMast.getLocNo(), NavigationMapType.DFX.id, assignCommand, shuttleThread);
            if (commands == null) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}小车，路径计算失败", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                return false;
            }

            List<ShuttleCommand> liftCommand = shuttleOperaUtils.getShuttleLiftCommand(assignCommand, shuttleThread, true);
            if (liftCommand == null) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}小车获取顶升命令失败", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                return false;
            }

            List<ShuttleCommand> liftCommand2 = shuttleOperaUtils.getShuttleLiftCommand(assignCommand, shuttleThread, false);
            if (liftCommand2 == null) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}小车获取下降命令失败", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                return false;
            }

            commands.add(0, liftCommand.get(0));
            commands.add(liftCommand2.get(0));
            assignCommand.setCommands(commands);

            wrkMast.setWrkSts(WrkStsType.LOC_MOVE_SHUTTLE_RUN.sts);//小车搬运中  501.生成移库任务 ==> 502.小车搬运中
            wrkMast.setModiTime(now);
            wrkMast.setSystemMsg("");//清空消息
            if (wrkMastService.updateById(wrkMast)) {
                //下发任务
                shuttleAction.assignWork(shuttleProtocol.getShuttleNo(), assignCommand);
                //触发通知
                notifyUtils.notify(String.valueOf(SlaveType.Shuttle), shuttleProtocol.getShuttleNo(), String.valueOf(wrkMast.getWrkNo()), NotifyMsgType.SHUTTLE_MOVING);
                return false;
            }
            return false;
        }
        return true;
    }

//    /**
@@ -1272,8 +1389,7 @@
//                                break;
                            case 306://306.提升机搬运中 ==> 307.提升机搬运完成
                                wrkMast.setWrkSts(WrkStsType.MOVE_LIFT_RUN_COMPLETE.sts);
                                //货叉提升机需要跳过迁出提升机流程
                                wrkMast.setWrkSts(WrkStsType.MOVE_OUT_LIFT_COMPLETE.sts);
                                forkLiftThread.setSyncTaskNo(0);
                                break;
                            default:
                        }
@@ -1293,221 +1409,162 @@
        }
    }

//    /**
//     * 异常信息记录
//     */
//    public void recErr() {
//        try {
//            this.recShuttleErr();
//            this.recLiftErr();
//        } catch (Exception e) {
//            News.error("recErr fail", e);
//        }
//    }
    /**
     * 异常信息记录
     */
    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()) {
//            // 获取四向穿梭车信息
//            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());
//                        }
//                    }
//                }
//            }
//        }
//    }
    /**
     * 四向穿梭车异常信息记录
     */
    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());
                        }
                    }
                }
            }
        }
    }

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

@@ -1611,206 +1668,6 @@
//    }

    /**
     * 出库  ===>> 工作档信息写入led显示器
     */
    public void ledExecute() {
//        try {
//            for (LedSlave led : slaveProperties.getLed()) {
//                // 获取输送线plc线程
//                DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, led.getDevpPlcId());
//                // 命令集合
//                List<LedCommand> commands = new ArrayList<>();
//                // 工作档集合
//                List<WrkMast> wrkMasts = new ArrayList<>();
//                List<WrkMastLog> wrkMastLogs = new ArrayList<>();
//                for (Integer staNo : led.getStaArr()) {
//                    // 获取叉车站点
//                    StaProtocol staProtocol = devpThread.getStation().get(staNo);
//                    if (null == staProtocol || null == staProtocol.getWorkNo() || 0 == staProtocol.getWorkNo() || !staProtocol.isLoading()) {
//                        continue;
//                    } else {
//                        staProtocol = staProtocol.clone();
//                    }
//                    // 获取工作档数据
//                    WrkMast wrkMast = wrkMastMapper.selectById(staProtocol.getWorkNo());
//                    Integer wrkNo = staProtocol.getWorkNo().intValue();
//                    Integer ioType = null;
//                    String sourceLocNo = null;
//                    String locNo = null;
//                    Integer wrkStaNo = null;
//                    String barcode = null;
//                    if (wrkMast == null) {
//                        //查询历史档
//                        WrkMastLog wrkMastLog = wrkMastLogMapper.selectLatestByWorkNo(staProtocol.getWorkNo().intValue());
//                        if (wrkMastLog == null) {
//                            continue;
//                        }
//                        ioType = wrkMastLog.getIoType();
//                        sourceLocNo = wrkMastLog.getSourceLocNo();
//                        locNo = wrkMastLog.getLocNo();
//                        wrkStaNo = wrkMastLog.getStaNo();
//                        barcode = wrkMastLog.getBarcode();
//                        wrkMastLogs.add(wrkMastLog);
//                    }else {
//                        if (wrkMast.getWrkSts() < 14 || wrkMast.getIoType() < 100) {
//                            continue;
//                        }
//                        ioType = wrkMast.getIoType();
//                        sourceLocNo = wrkMast.getSourceLocNo();
//                        locNo = wrkMast.getLocNo();
//                        wrkStaNo = wrkMast.getStaNo();
//                        barcode = wrkMast.getBarcode();
//                        wrkMasts.add(wrkMast);
//                    }
//                    // 组装命令
//                    LedCommand ledCommand = new LedCommand();
//                    ledCommand.setWorkNo(wrkNo);
//                    ledCommand.setIoType(ioType);
//                    // 出库模式
//                    switch (ioType) {
//                        case 101:
//                            ledCommand.setTitle("全板出库");
//                            break;
//                        case 103:
//                            ledCommand.setTitle("拣料出库");
//                            break;
//                        case 104:
//                            ledCommand.setTitle("并板出库");
//                            break;
//                        case 107:
//                            ledCommand.setTitle("盘点出库");
//                            break;
//                        case 110:
//                            ledCommand.setTitle("空板出库");
//                            ledCommand.setEmptyMk(true);
//                            break;
//                        default:
//                            News.error("任务入出库类型错误！！！[工作号：{}] [入出库类型：{}]", wrkNo, ioType);
//                            break;
//                    }
//                    ledCommand.setSourceLocNo(sourceLocNo);
//                    ledCommand.setLocNo(locNo);
//                    ledCommand.setStaNo(wrkStaNo);
//                    ledCommand.setBarcode(barcode);
//                    if (ioType != 110 && ioType != 10) {
//                        List<WrkDetl> wrkDetls = wrkDetlService.selectList(new EntityWrapper<WrkDetl>().eq("wrk_no", wrkNo));
//                        if (!wrkDetls.isEmpty()) {
//                            wrkDetls.forEach(wrkDetl -> {
//                                double remainNum = wrkDetl.getStock() - wrkDetl.getAnfme();//剩余数量
//                                if (remainNum < 0) {
//                                    remainNum = 0;
//                                }
//                                String matnr = wrkDetl.getMatnr();
//                                Mat mat = matService.selectByMatnr(wrkDetl.getMatnr());
//                                if (mat != null) {
//                                    if (!mat.getMatnr().equals(mat.getMatnr2())) {
//                                        matnr += " - " + mat.getMatnr2();
//                                    }
//                                }
//                                ledCommand.getMatDtos().add(new MatDto(matnr, wrkDetl.getMaktx(), wrkDetl.getAnfme(), remainNum, wrkDetl.getSpecs(), wrkDetl.getSuppCode(), wrkDetl.getOrderNo()));
//                            });
//                        }else {
//                            List<WrkDetlLog> wrkDetlLogs = wrkDetlLogService.selectLatestByWorkNo(wrkNo, barcode);
//                            for (WrkDetlLog wrkDetlLog : wrkDetlLogs) {
//                                double remainNum = wrkDetlLog.getStock() - wrkDetlLog.getAnfme();//剩余数量
//                                if (remainNum < 0) {
//                                    remainNum = 0;
//                                }
//                                String matnr = wrkDetlLog.getMatnr();
//                                Mat mat = matService.selectByMatnr(wrkDetlLog.getMatnr());
//                                if (mat != null) {
//                                    if (!mat.getMatnr().equals(mat.getMatnr2())) {
//                                        matnr += " - " + mat.getMatnr2();
//                                    }
//                                }
//                                ledCommand.getMatDtos().add(new MatDto(matnr, wrkDetlLog.getMaktx(), wrkDetlLog.getAnfme(), remainNum, wrkDetlLog.getSpecs(), wrkDetlLog.getSuppCode()));
//                            }
//                        }
//                    commands.add(ledCommand);
//                }
//                Set<Integer> workNos = null;
//                if (!wrkMasts.isEmpty()) {
//                    workNos = wrkMasts.stream().map(WrkMast::getWrkNo).collect(Collectors.toSet());
//                }else {
//                    workNos = wrkMastLogs.stream().map(WrkMastLog::getWrkNo).collect(Collectors.toSet());
//                }
//                // 获取LED线程
//                LedThread ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, led.getId());
//                // 相同工作号集合则过滤
//                if (CollectionUtils.equals(ledThread.getWorkNos(), workNos)) {
//                    continue;
//                }
//                // 命令下发 -------------------------------------------------------------------------------
//                if (!commands.isEmpty()) {
//                    if (!MessageQueue.offer(SlaveType.Led, led.getId(), new Task(1, commands))) {
//                        log.error("{}号LED命令下发失败！！！[ip：{}] [port：{}]", led.getId(), led.getIp(), led.getPort());
//                        continue;
//                    } else {
//                        ledThread.setLedMk(false);
//                    }
//                }
//
//                try {
//                    // 修改主档led标记
//                    for (WrkMast wrkMast : wrkMasts) {
//                        wrkMast.setOveMk("Y");
//                        wrkMast.setModiTime(new Date());
//                        if (wrkMastMapper.updateById(wrkMast) == 0) {
//                            throw new CoolException("更新工作档失败");
//                        }
//                    }
//
//                    // 更新线程当前工作号集合
//                    ledThread.setWorkNos(workNos);
//
//                } catch (Exception e) {
//                    e.printStackTrace();
//                    TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
//                }
//
//            }
//        } catch (Exception e) {
//            e.printStackTrace();
//        }
    }

    /**
     * 其他  ===>> LED显示器复位，显示默认信息
     */
    public void ledReset() {
//        try {
//            for (LedSlave led : slaveProperties.getLed()) {
//                // 获取输送线plc线程
//                DevpThread devpThread = (DevpThread) SlaveConnection.get(SlaveType.Devp, led.getDevpPlcId());
//                // 命令集合
//                boolean reset = true;
//                for (Integer staNo : led.getStaArr()) {
//                    // 获取叉车站点
//                    StaProtocol staProtocol = devpThread.getStation().get(staNo);
//                    if (staProtocol == null) {
//                        continue;
//                    }
//                    if (staProtocol.isLoading()) {
//                        reset = false;
//                        break;
//                    }
//                }
//                // 获取led线程
//                LedThread ledThread = (LedThread) SlaveConnection.get(SlaveType.Led, led.getId());
//                // led显示默认内容
//                if (reset) {
//                    ledThread.setLedMk(true);
//                    if (!MessageQueue.offer(SlaveType.Led, led.getId(), new Task(2, new ArrayList<>()))) {
//                        log.error("{}号LED命令下发失败！！！[ip：{}] [port：{}]", led.getId(), led.getIp(), led.getPort());
//                    }
//                }
//            }
//        } catch (Exception e) {
//            e.printStackTrace();
//        }
    }

    /**
     * 四向穿梭车电量检测 ===>> 发起充电
     */
    public synchronized void loopShuttleCharge() {
@@ -1901,7 +1758,7 @@
     */
    public synchronized void executeShuttleCharge() {
        try {
            //查询小车移库任务
            //查询小车充电任务
            for (ShuttleSlave shuttle : slaveProperties.getShuttle()) {
                WrkMast wrkMast = wrkMastService.selectChargeWorking(shuttle.getId());
                if(wrkMast == null) {
@@ -2027,7 +1884,7 @@
            assignCommand.setTaskMode(ShuttleTaskModeType.CHARGE.id);//出库模式
            assignCommand.setSourceLocNo(shuttleProtocol.getCurrentLocNo());//源库位(小车当前位置)

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

            wrkMast.setWrkSts(WrkStsType.CHARGE_SHUTTLE_WORKING.sts);
@@ -2038,6 +1895,8 @@

            //下发任务
            shuttleAction.assignWork(shuttleProtocol.getShuttleNo(), assignCommand);

            notifyUtils.notify(String.valueOf(SlaveType.Shuttle), shuttleProtocol.getShuttleNo(), String.valueOf(wrkMast.getWrkNo()), NotifyMsgType.SHUTTLE_POWER_START);//触发通知
            return false;
        }
        return true;
@@ -2066,14 +1925,8 @@
            assignCommand.setTaskMode(ShuttleTaskModeType.CHARGE.id);//出库模式
            assignCommand.setSourceLocNo(shuttleProtocol.getCurrentLocNo());//源库位(小车当前位置)

            List<ShuttleCommand> commands = shuttleOperaUtils.shuttleChargeCommand(assignCommand, shuttleThread, false);
            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);
@@ -2094,22 +1947,22 @@
                return false;
            }

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

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

            wrkMast.setWrkSts(WrkStsType.COMPLETE_CHARGE.sts);
            wrkMast.setModiTime(new Date());
            if (wrkMastService.updateById(wrkMast)) {
                return false;
            }
            return false;
        }
        return true;
@@ -2130,6 +1983,11 @@

                boolean stepLiftMove = this.shuttleMoveExecuteStepLiftMove(wrkMast);//提升机搬运中
                if (!stepLiftMove) {
                    continue;
                }

                boolean updateShuttleLocation = this.shuttleMoveExecuteStepUpdateShuttleLocation(wrkMast);//提升机搬运完成更新小车坐标
                if (!updateShuttleLocation) {
                    continue;
                }

@@ -2167,7 +2025,7 @@

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

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

            ShuttleAssignCommand assignCommand = new ShuttleAssignCommand();
            assignCommand.setShuttleNo(shuttleProtocol.getShuttleNo()); // 四向穿梭车编号
            assignCommand.setTaskMode(ShuttleTaskModeType.MOVE_LOC_NO.id);//小车移库任务
            assignCommand.setTaskNo(wrkMast.getWrkNo());//任务号
            assignCommand.setAuto(true);//自动模式

            //获取小车到输送站点行走命令
            List<ShuttleCommand> commands = shuttleOperaUtils.getStartToTargetCommands(shuttleProtocol.getCurrentLocNo(), liftSta.getLocNo(), NavigationMapType.NORMAL.id, assignCommand, shuttleThread);
            if (commands == null) {
                News.info("{}任务，{}小车，路径计算失败", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                return false;//路径解锁失败
            }

            assignCommand.setCommands(commands);

            //*************尝试锁定目标站路径***************
            List<NavigateNode> targetNodes = ForkLiftUtils.getLiftStaNodes(wrkMast.getStaNo());
@@ -2228,13 +2071,34 @@
            }
            //*************尝试锁定目标站路径***************

            ShuttleAssignCommand assignCommand = new ShuttleAssignCommand();
            assignCommand.setShuttleNo(shuttleProtocol.getShuttleNo()); // 四向穿梭车编号
            assignCommand.setTaskMode(ShuttleTaskModeType.MOVE_LOC_NO.id);//小车移库任务
            assignCommand.setTaskNo(wrkMast.getWrkNo());//任务号
            assignCommand.setAuto(true);//自动模式

            //获取小车到输送站点行走命令
            List<ShuttleCommand> commands = shuttleOperaUtils.getStartToTargetCommands(shuttleProtocol.getCurrentLocNo(), liftSta.getLocNo(), NavigationMapType.NORMAL.id, assignCommand, shuttleThread);
            if (commands == null) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}小车，路径计算失败", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());

                //所使用的路径进行锁定禁用
                navigateMapUtils.writeNavigateNodeToRedisMap(Utils.getLev(wrkMast.getLocNo()), shuttleProtocol.getShuttleNo(), targetNodes, false);
                return false;//路径解锁失败
            }

            assignCommand.setCommands(commands);

            wrkMast.setWrkSts(WrkStsType.MOVE_SITE.sts);//小车移动到提升机中  301.生成小车移库任务 ==> 302.小车移动至站点
            wrkMast.setModiTime(now);
            wrkMast.setLiftNo(liftSta.getLiftNo());//提前锁定提升机
            wrkMast.setSystemMsg("");//清空消息
//            shuttleProtocol.setToken(wrkMast.getWrkNo());//独占该小车令牌
            if (wrkMastService.updateById(wrkMast)) {
                //下发任务
                shuttleAction.assignWork(shuttleProtocol.getShuttleNo(), assignCommand);
                //触发通知
                notifyUtils.notify(String.valueOf(SlaveType.Shuttle), shuttleProtocol.getShuttleNo(), String.valueOf(wrkMast.getWrkNo()), NotifyMsgType.SHUTTLE_MOVING);
                return false;
            }
            return false;
@@ -2262,14 +2126,14 @@
                return false;
            }
            if (!forkLiftThread.isIdle()) {
                News.info("{}任务，{}号提升机，提升机忙碌中，禁止派发", wrkMast.getWrkNo(), wrkMast.getLiftNo());
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}号提升机，提升机忙碌中，禁止派发", wrkMast.getWrkNo(), wrkMast.getLiftNo());
                return false;
            }
            //判断提升机是否有其他任务
            WrkMast liftWrkMast = wrkMastService.selectLiftWrkMast(wrkMast.getLiftNo());
            if (liftWrkMast != null) {
                if (!liftWrkMast.getWrkNo().equals(wrkMast.getWrkNo())) {//提升机任务和当前任务不相同
                    News.info("{}任务，{}号提升机，提升机存在未完成任务，禁止派发", wrkMast.getWrkNo(), wrkMast.getLiftNo());
                    News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}号提升机，提升机存在未完成任务，禁止派发", wrkMast.getWrkNo(), wrkMast.getLiftNo());
                    return false;//当前提升机存在未完成任务，等待下一次轮询
                }
            }
@@ -2279,10 +2143,14 @@
            //获取目标站
            ForkLiftStaProtocol liftSta = ForkLiftUtils.getLiftStaByStaNo(wrkMast.getStaNo());
            if (sourceLiftSta == null || liftSta == null) {
                News.info("{}任务，缺少站点信息，禁止派发", wrkMast.getWrkNo());
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，缺少站点信息，禁止派发", wrkMast.getWrkNo());
                return false;//缺少站点信息
            }

            if (liftSta.getHasTray()) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，目标站存在托盘，禁止派发", wrkMast.getWrkNo());
                return false;//有托盘跳过
            }

            //获取提升机命令
            List<ForkLiftCommand> liftCommands = forkLiftThread.getShuttleSwitchCommand(wrkMast.getWrkNo(), sourceLiftSta.getLev(), liftSta.getLev());
@@ -2297,10 +2165,65 @@
            assignCommand.setTaskMode(ForkLiftTaskModeType.SHUTTLE_SWITCH.id.shortValue());

            wrkMast.setWrkSts(WrkStsType.MOVE_LIFT_RUN.sts);//提升机搬运中  303.小车移动至站点完成 ==> 306.提升机搬运中
            wrkMast.setSystemMsg("");//清空消息
            wrkMast.setModiTime(now);
            if (wrkMastService.updateById(wrkMast)) {
                //下发任务
                forkLiftAction.assignWork(wrkMast.getLiftNo(), assignCommand);
            }
        }
        return true;
    }

    /**
     * 小车迁移-提升机搬运完成更新小车坐标
     * 如需主方法执行continue，请返回false
     * ps:返回值true并不代表该方法执行成功，返回值仅做标记用于主方法是否执行continue
     */
    private boolean shuttleMoveExecuteStepUpdateShuttleLocation(WrkMast wrkMast) {
        //--------------------------------------提升机搬运中-----------------------------------------//
        Date now = new Date();

        //提升机搬运中  307.提升机搬运完成 ==> 308.小车迁出提升机中
        if (wrkMast.getWrkSts() == WrkStsType.MOVE_LIFT_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;
            }

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

            ShuttleAssignCommand assignCommand = new ShuttleAssignCommand();
            assignCommand.setShuttleNo(shuttleProtocol.getShuttleNo()); // 四向穿梭车编号
            assignCommand.setTaskMode(ShuttleTaskModeType.UPDATE_LOCATION.id);//更新坐标
            assignCommand.setTaskNo(wrkMast.getWrkNo());//任务号
            assignCommand.setAuto(true);//自动模式
            assignCommand.setSourceLocNo(shuttleProtocol.getCurrentLocNo());//源库位
            assignCommand.setLocNo(wrkMast.getLocNo());//目标库位

            //更新小车坐标
            ShuttleCommand command = shuttleThread.getUpdateLocationCommand(wrkMast.getWrkNo(), wrkMast.getLocNo());
            ArrayList<ShuttleCommand> commands = new ArrayList<>();
            commands.add(command);

            assignCommand.setCommands(commands);

            wrkMast.setWrkSts(WrkStsType.MOVE_OUT_LIFT.sts);//小车迁出提升机中
            wrkMast.setSystemMsg("");//清空消息
            wrkMast.setModiTime(now);

            if (wrkMastService.updateById(wrkMast)) {
                //下发任务
                shuttleAction.assignWork(shuttleProtocol.getShuttleNo(), assignCommand);
            }
        }
        return true;
@@ -2330,7 +2253,7 @@

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

@@ -2340,17 +2263,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;
            }

@@ -2365,51 +2277,33 @@
            List<ShuttleCommand> commands = null;
            //跨楼层移动任务
            if (Utils.getLev(wrkMast.getSourceLocNo()) != Utils.getLev(wrkMast.getLocNo())) {
//                //需要将前两个节点作为白名单节点传入
//                //获取目标站
//                LiftStaProtocol liftSta = NyLiftUtils.getLiftStaByStaNo(wrkMast.getStaNo());
//                if (liftSta == null) {
//                    return false;//找不到站点
//                }
//
//                List<NavigateNode> targetNodes = NyLiftUtils.getLiftStaNodes(liftSta.getStaNo());
//                if (targetNodes == null) {
//                    return false;//未获取到节点
//                }
//
//                //设置计算节点的白名单
//                ArrayList<int[]> whiteList = new ArrayList<>();//设置计算节点的白名单
//                for (NavigateNode node : targetNodes) {
//                    whiteList.add(new int[]{node.getX(), node.getY()});
//                }
//                commands = shuttleOperaUtils.getStartToTargetCommands(shuttleProtocol.getCurrentLocNo(), wrkMast.getLocNo(), NavigationMapType.NORMAL.id, assignCommand, shuttleThread, whiteList);
                //需要将前两个节点作为白名单节点传入
                List<NavigateNode> targetNodes = ForkLiftUtils.getLiftStaNodes(wrkMast.getStaNo());
                if (targetNodes == null) {
                    return false;//未获取到节点
                }

                //设置计算节点的白名单
                ArrayList<int[]> whiteList = new ArrayList<>();//设置计算节点的白名单
                for (NavigateNode node : targetNodes) {
                    whiteList.add(new int[]{node.getX(), node.getY()});
                }
                commands = shuttleOperaUtils.getStartToTargetCommands(shuttleProtocol.getCurrentLocNo(), wrkMast.getLocNo(), NavigationMapType.NORMAL.id, whiteList, assignCommand, shuttleThread);
            }else {
                //获取小车到目标库位命令
                commands = shuttleOperaUtils.getStartToTargetCommands(shuttleProtocol.getCurrentLocNo(), wrkMast.getLocNo(), NavigationMapType.NORMAL.id, assignCommand, shuttleThread);
            }

            if (commands == null) {
                News.taskInfo(wrkMast.getWrkNo(), "{}任务，{}小车，路径计算失败", wrkMast.getWrkNo(), shuttleProtocol.getShuttleNo());
                return false;//路径计算失败
            }

            assignCommand.setCommands(commands);

//            if (wrkMast.getLiftNo() != null) {
//                LiftThread liftThread = (LiftThread) SlaveConnection.get(SlaveType.Lift, wrkMast.getLiftNo());
//                if (liftThread == null) {
//                    return false;
//                }
//                LiftProtocol liftProtocol = liftThread.getLiftProtocol();
//                if (liftProtocol == null) {
//                    return false;
//                }
//                if (liftProtocol.getToken().equals(shuttleProtocol.getShuttleNo())) {
//                    liftProtocol.setToken(0);//释放提升机令牌
//                }
//            }

            wrkMast.setWrkSts(WrkStsType.MOVE_SHUTTLE.sts);//小车移动到目标库位中  309.小车迁出提升机完成 ==> 310.小车移动中
            wrkMast.setLiftNo(null);//释放提升机
            wrkMast.setSystemMsg("");//清空消息
            wrkMast.setModiTime(now);

            if (wrkMastService.updateById(wrkMast)) {
@@ -2419,41 +2313,5 @@
        }
        return true;
    }

//    //扫描设备PakMk标记是否超时
//    public synchronized void scanDevicePakMk() {
//        try {
//            //扫描小车
//            for (ShuttleSlave slave : slaveProperties.getShuttle()) {
//                NyShuttleThread shuttleThread = (NyShuttleThread) SlaveConnection.get(SlaveType.Shuttle, slave.getId());
//                NyShuttleProtocol shuttleProtocol = shuttleThread.getShuttleProtocol();
//                if (shuttleProtocol == null) {
//                    continue;
//                }
//
//                if ((System.currentTimeMillis() - shuttleProtocol.getSendTime() > (1000 * 60 * 5)) && shuttleProtocol.getPakMk()) {
//                    //设备超过5分钟还没复位标记
//                    shuttleProtocol.setPakMk(false);//复位标记
//                }
//            }
//
//            //扫描提升机
//            for (LiftSlave slave : slaveProperties.getLift()) {
//                LiftThread liftThread = (LiftThread) SlaveConnection.get(SlaveType.Lift, slave.getId());
//                LiftProtocol liftProtocol = liftThread.getLiftProtocol();
//                if (liftProtocol == null) {
//                    continue;
//                }
//
//                if ((System.currentTimeMillis() - liftProtocol.getSendTime() > (1000 * 60 * 5)) && liftProtocol.getPakMk()) {
//                    //设备超过5分钟还没复位标记
//                    liftProtocol.setPakMk(false);//复位标记
//                }
//            }
//        } catch (Exception e) {
//            e.printStackTrace();
//        }
//
//    }

}