#输送线读取

Junjie

2023-12-08 ff2b6e2329ae2c5d3fede2f9413170fd6e87c46c

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

@@ -1,29 +1,40 @@
package com.zy.core.thread;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.core.common.DateUtils;
import com.core.common.SpringUtils;
import com.zy.asrs.entity.*;
import com.zy.asrs.mapper.WrkMastMapper;
import com.zy.asrs.service.*;

import com.zy.asrs.utils.Utils;
import com.zy.common.model.NavigateNode;
import com.zy.common.service.CommonService;
import com.zy.common.utils.*;
import com.zy.core.News;
import com.zy.core.ThreadHandler;
import com.zy.core.cache.MessageQueue;
import com.zy.core.cache.OutputQueue;
import com.zy.core.cache.SlaveConnection;
import com.zy.core.enums.*;
import com.zy.core.model.LiftSlave;
import com.zy.core.model.ShuttleSlave;
import com.zy.core.model.Task;
import com.zy.core.model.command.NyShuttleHttpCommand;
import com.zy.core.model.command.ShuttleAssignCommand;
import com.zy.core.model.command.ShuttleCommand;
import com.zy.core.model.command.*;
import com.zy.core.model.protocol.LiftProtocol;
import com.zy.core.model.protocol.NyShuttleProtocol;
import com.zy.core.properties.SlaveProperties;
import lombok.Data;
import lombok.extern.slf4j.Slf4j;

import java.io.IOException;
import java.net.Socket;
import java.text.MessageFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;

/**
 * 牛眼四向穿梭车线程
@@ -35,6 +46,7 @@
    private ShuttleSlave slave;
    private NyShuttleProtocol shuttleProtocol;
    private RedisUtil redisUtil;
    private Socket socket;

    public NyShuttleThread(ShuttleSlave slave,RedisUtil redisUtil) {
        this.slave = slave;
@@ -56,10 +68,10 @@
                    case 1:
                        read();
                        break;
                    // 写入数据
                    case 2:
                        write((ShuttleCommand) task.getData());
                        break;
//                    // 写入数据
//                    case 2:
//                        write((NyShuttleHttpCommand) task.getData());
//                        break;
                    //下发任务
                    case 3:
                        assignWork((ShuttleAssignCommand) task.getData());
@@ -76,13 +88,22 @@

    private void read() {
        try {
            if (this.socket == null || this.socket.isClosed()) {
                //链接断开重新链接
                this.connect();
            }
            readStatus();
            //四向穿梭车空闲、有任务、标记为true、存在任务指令，需要执行任务的下一条指令
            if (shuttleProtocol.getFree() == ShuttleStatusType.IDLE.id
                    && shuttleProtocol.getTaskNo() != 0
                    && shuttleProtocol.getPakMk()) {
                    && !shuttleProtocol.getPakMk()) {
                //执行下一步指令
                executeWork(shuttleProtocol.getTaskNo());
                executeWork(shuttleProtocol.getTaskNo().shortValue());
            }

            //小车空闲且有跑库程序
            if (shuttleProtocol.isIdle() && shuttleProtocol.getMoveLoc()) {
                moveLoc();
            }
        } catch (Exception e) {
            e.printStackTrace();
@@ -92,17 +113,12 @@

    private void readStatus() {
        try {
            if (null == shuttleProtocol) {
                shuttleProtocol = new NyShuttleProtocol();
                shuttleProtocol.setShuttleNo(slave.getId().shortValue());
                shuttleProtocol.setProtocolStatus(ShuttleProtocolStatusType.IDLE);
            }

            //----------读取四向穿梭车状态-----------
            NyShuttleHttpCommand readStatusCommand = NyHttpUtils.getReadStatusCommand(slave.getId());
            JSONObject jsonObject = NyHttpUtils.requestCommand(readStatusCommand);
            JSONObject jsonObject = NyHttpUtils.requestCommand(socket, readStatusCommand);
            if (jsonObject == null) {
                OutputQueue.SHUTTLE.offer(MessageFormat.format("【{0}】四向穿梭车plc状态信息失败 ===>> [id:{1}] [ip:{2}] [port:{3}]", DateUtils.convert(new Date()), slave.getId(), slave.getIp(), slave.getPort()));
                shuttleProtocol.setProtocolStatus(ShuttleProtocolStatusType.OFFLINE);
                OutputQueue.SHUTTLE.offer(MessageFormat.format("【{0}】四向穿梭车Socket状态信息失败 ===>> [id:{1}] [ip:{2}] [port:{3}]", DateUtils.convert(new Date()), slave.getId(), slave.getIp(), slave.getPort()));
            }else {
                //手动状态/自动状态
                shuttleProtocol.setWorkingMode(jsonObject.getInteger("workingMode"));
@@ -151,15 +167,15 @@
                    errCode.add(Integer.parseInt(o.toString()));
                }
                //故障码
                shuttleProtocol.setErrCode(errCode);
                shuttleProtocol.setErrCode(errCode.get(0));
                //总里程数
                shuttleProtocol.setStatusSum(jsonObject.getObject("statusSum", NyShuttleProtocol.StatusSumClass.class));
                //非自动状态时间计时
                shuttleProtocol.setErrTime(jsonObject.getInteger("errTime"));

                //小车处于运行中，将标记置为true
                //小车处于运行中，将标记置为false
                if (shuttleProtocol.getFree() == 0) {
                    shuttleProtocol.setPakMk(true);
                    shuttleProtocol.setPakMk(false);
                }

                //将四向穿梭车状态保存至数据库
@@ -225,15 +241,38 @@
                    OutputQueue.SHUTTLE.offer(MessageFormat.format("【{0}】[id:{1}] <<<<< 实时数据更新成功",DateUtils.convert(new Date()), slave.getId()));
//                    log.info(MessageFormat.format("【{0}】[id:{1}] <<<<< 实时数据更新成功",DateUtils.convert(new Date()), slave.getId()));
                }
//                log.warn(JSON.toJSONString(shuttleProtocol));//输出小车状态
            }
        } catch (Exception e) {
            e.printStackTrace();
            OutputQueue.SHUTTLE.offer(MessageFormat.format("【{0}】四向穿梭车plc状态信息失败 ===>> [id:{1}] [ip:{2}] [port:{3}]", DateUtils.convert(new Date()), slave.getId(), slave.getIp(), slave.getPort()));
            OutputQueue.SHUTTLE.offer(MessageFormat.format("【{0}】四向穿梭车Socket状态信息失败 ===>> [id:{1}] [ip:{2}] [port:{3}]", DateUtils.convert(new Date()), slave.getId(), slave.getIp(), slave.getPort()));
            try {
                this.socket.close();
                this.socket = null;
                Thread.sleep(1000);
                this.connect();
            } catch (IOException | InterruptedException exception) {
                e.printStackTrace();
            }
        }
    }

    @Override
    public boolean connect() {
        try {
            Socket socket = new Socket(slave.getIp(),slave.getPort());
            socket.setSoTimeout(60000);
            socket.setKeepAlive(true);
            this.socket = socket;
            if (null == shuttleProtocol) {
                shuttleProtocol = new NyShuttleProtocol();
                shuttleProtocol.setShuttleNo(slave.getId().shortValue());
            }
            shuttleProtocol.setProtocolStatus(ShuttleProtocolStatusType.IDLE);
            log.info(MessageFormat.format("【{0}】四向穿梭车Socket链接成功 ===>> [id:{1}] [ip:{2}] [port:{3}]", DateUtils.convert(new Date()), slave.getId(), slave.getIp(), slave.getPort()));
        } catch (IOException e) {
            OutputQueue.SHUTTLE.offer(MessageFormat.format("【{0}】四向穿梭车Socket链接失败 ===>> [id:{1}] [ip:{2}] [port:{3}]", DateUtils.convert(new Date()), slave.getId(), slave.getIp(), slave.getPort()));
        }
        return true;
    }

@@ -242,7 +281,7 @@

    }

    private boolean write(ShuttleCommand command){
    private boolean write(NyShuttleHttpCommand command, ShuttleAssignCommand assignCommand) {
        if (null == command) {
            News.error("四向穿梭车写入命令为空");
            return false;
@@ -258,558 +297,581 @@
            News.error("四向穿梭车不存在");
            return false;
        }
//        command.setShuttleNo(slave.getId().shortValue());
//        short[] array = getCommandArr(command);//获取命令报文
//        OperateResult result = modbusTcpNet.Write("0", array);
//        if (result != null && result.IsSuccess) {
//            News.info("四向穿梭车命令下发[id:{}] >>>>> {}", slave.getId(), JSON.toJSON(command));
//            OutputQueue.SHUTTLE.offer(MessageFormat.format("【{0}】[id:{1}] >>>>> 命令下发： {2}", DateUtils.convert(new Date()), slave.getId(), JSON.toJSON(command)));
//
//            try {
//                Thread.sleep(3000);//命令下发后休眠
//            } catch (InterruptedException e) {
//                throw new RuntimeException(e);
//            }
//
//            for (int i = 0; i < 5; i++) {
//                if (command.getCommandWord().intValue() == 5 || command.getCommandWord().intValue() == 6) {
//                    break;//充电开关和系统复位不需要重发机制
//                }
//                readStatus();//重新读取状态
//                if (shuttleProtocol.getBusyStatusType().equals(ShuttleStatusType.BUSY)) {
//                    break;
//                }
//
//                //判断是否运行中，如不运行，重新下发命令
//                result = modbusTcpNet.Write("0", array);
//                News.info("四向穿梭车命令下发[id:{}] >>>>> {},次数：{}", slave.getId(), JSON.toJSON(command), i);
//                OutputQueue.SHUTTLE.offer(MessageFormat.format("【{0}】[id:{1}] >>>>> 命令下发： {2},次数：{}", DateUtils.convert(new Date()), slave.getId(), JSON.toJSON(command), i));
//                try {
//                    Thread.sleep(300);//命令下发后休眠
//                } catch (InterruptedException e) {
//                    throw new RuntimeException(e);
//                }
//            }
//
//            return true;
//        } else {
//            OutputQueue.SHUTTLE.offer(MessageFormat.format("【{0}】写入四向穿梭车plc数据失败 ===>> [id:{1}] [ip:{2}] [port:{3}],次数：{}", DateUtils.convert(new Date()), slave.getId(), slave.getIp(), slave.getPort()));
//            News.error("写入四向穿梭车plc数据失败 ===>> [id:{}] [ip:{}] [port:{}]", slave.getId(), slave.getIp(), slave.getPort());
//            return false;
//        }

        return false;
        //发出请求
        JSONObject result = null;
        try {
            result = NyHttpUtils.requestCommand(socket, command);
        } catch (IOException e) {
            try {
                this.socket.close();
                this.socket = null;
                Thread.sleep(1000);
                this.connect();
            } catch (IOException exception) {
                exception.printStackTrace();
            } catch (InterruptedException ex) {
                throw new RuntimeException(ex);
            }
        }

        //保存数据到数据库做流水
        BasShuttleOptService shuttleOptService = SpringUtils.getBean(BasShuttleOptService.class);
        BasShuttleOpt opt = null;
        if (shuttleOptService != null) {
            opt = new BasShuttleOpt(
                    assignCommand.getTaskNo().intValue(),
                    assignCommand.getShuttleNo().intValue(),
                    new Date(),
                    ShuttleTaskModeType.get(assignCommand.getTaskMode()).desc,
                    assignCommand.getSourceLocNo(),
                    assignCommand.getLocNo(),
                    null,
                    null,
                    null,
                    JSON.toJSONString(command),
                    null,
                    JSON.toJSONString(shuttleProtocol)
            );
            opt.setSend(1);//已下发
            opt.setResponse(JSON.toJSONString(result));//请求响应
            opt.setDeviceWrk(command.getWrkNo().toString());//设备工作号
            shuttleOptService.insert(opt);
        }

        if (result == null) {
            return false;//请求失败
        }
        return true;
    }

    //分配任务
    private void assignWork(ShuttleAssignCommand assignCommand) {
//        ShuttleRedisCommand redisCommand = new ShuttleRedisCommand();
//
//        if (!assignCommand.getAuto()) {
//            List<NavigateNode> allNode = new ArrayList<>();
//            List<ShuttleCommand> commands = new ArrayList<>();
//            LocMastService locMastService = SpringUtils.getBean(LocMastService.class);
//            BasShuttleService shuttleService = SpringUtils.getBean(BasShuttleService.class);
//            NavigateMapData navigateMapData;
//
//            //获取小车移动速度
//            BasShuttle basShuttle = shuttleService.selectById(slave.getId());
//            Integer runSpeed = 1000;
//            if (basShuttle != null) {
//                Integer runSpeed1 = basShuttle.getRunSpeed();
//                if (runSpeed1 != null) {
//                    runSpeed = runSpeed1;
//                }
//            }
//
//            LiftThread liftThread = (LiftThread) SlaveConnection.get(SlaveType.Lift, 1);
//            LiftProtocol liftProtocol = liftThread.getLiftProtocol();
//
//            switch (assignCommand.getTaskMode()) {
//                case 1://入库
//                case 2://出库
//                    //小车移动到提升机口，计算路径
//                    //计算小车起点到中点所需命令
//                    LocMast currentLocMast = locMastService.queryByQrCode(shuttleProtocol.getCurrentCode().toString());
//                    List<NavigateNode> firstMastResult = NavigateUtils.calc(currentLocMast.getLocNo(), assignCommand.getSourceLocNo(), NavigationMapType.NORMAL.id, Utils.getShuttlePoints(assignCommand.getShuttleNo().intValue(), Utils.getLev(currentLocMast.getLocNo())));//小车到中点，处于无货状态，使用正常通道地图
//                    boolean checkResult = Utils.checkShuttlePath(firstMastResult, shuttleProtocol.getShuttleNo().intValue());
//                    if (firstMastResult != null && checkResult) {
//                        allNode.addAll(firstMastResult);//将节点进行保存
//                        //获取分段路径
//                        ArrayList<ArrayList<NavigateNode>> data = NavigateUtils.getSectionPath(firstMastResult);
//                        //将每一段路径分成command指令
//                        for (ArrayList<NavigateNode> nodes : data) {
//                            //开始路径
//                            NavigateNode startPath = nodes.get(0);
//                            //中间路径
//                            NavigateNode middlePath = nodes.get(nodes.size() - 2);
//                            //目标路径
//                            NavigateNode endPath = nodes.get(nodes.size() - 1);
//                            Integer allDistance = NavigateUtils.getCurrentPathAllDistance(nodes);//计算当前路径行走总距离
//                            Integer middleToDistDistance = NavigateUtils.getMiddleToDistDistance(nodes, middlePath);//计算中间点到目标点行走距离
//
//                            //正常移动命令
//                            Short startCode = NavigatePositionConvert.xyToPosition(startPath.getX(), startPath.getY(), startPath.getZ());//开始二维码
//                            Short middleCode = NavigatePositionConvert.xyToPosition(middlePath.getX(), middlePath.getY(), middlePath.getZ());//目标二维码
//                            Short distCode = NavigatePositionConvert.xyToPosition(endPath.getX(), endPath.getY(), endPath.getZ());//目标二维码
//                            commands.add(getMoveCommand(startCode, distCode, allDistance, ShuttleRunDirection.get(startPath.getDirection()).id, middleCode, middleToDistDistance, runSpeed));
//                        }
//
//                        //托盘顶升
//                        commands.add(getPalletCommand((short) 1));
//                    }else {
//                        //没有计算到路径，可能存在小车位置就是起点位置
//                        if (currentLocMast.getLocNo().equals(assignCommand.getSourceLocNo())) {
//                            //小车位置就是起点位置，无需移动，直接顶升
//                            //托盘顶升
//                            commands.add(getPalletCommand((short) 1));
//                        }
//                    }
//
//                    //计算中点到终点路径
//                    List<NavigateNode> secMastResult = NavigateUtils.calc(assignCommand.getSourceLocNo(), assignCommand.getLocNo(), NavigationMapType.DFX.id, Utils.getShuttlePoints(assignCommand.getShuttleNo().intValue(), Utils.getLev(assignCommand.getSourceLocNo())));//小车从中点到终点，处于有货状态，使用DFX地图
//                    boolean checkResult2 = Utils.checkShuttlePath(secMastResult, shuttleProtocol.getShuttleNo().intValue());
//                    if (secMastResult != null && checkResult2) {
//                        allNode.addAll(secMastResult);//将节点进行保存
//                        //获取分段路径
//                        ArrayList<ArrayList<NavigateNode>> data = NavigateUtils.getSectionPath(secMastResult);
//                        //将每一段路径分成command指令
//                        for (ArrayList<NavigateNode> nodes : data) {
//                            //开始路径
//                            NavigateNode startPath = nodes.get(0);
//                            //中间路径
//                            NavigateNode middlePath = nodes.get(nodes.size() - 2);
//                            //目标路径
//                            NavigateNode endPath = nodes.get(nodes.size() - 1);
//                            Integer allDistance = NavigateUtils.getCurrentPathAllDistance(nodes);//计算当前路径行走总距离
//                            Integer middleToDistDistance = NavigateUtils.getMiddleToDistDistance(nodes, middlePath);//计算中间点到目标点行走距离
//
//                            //正常移动命令
//                            Short startCode = NavigatePositionConvert.xyToPosition(startPath.getX(), startPath.getY(), startPath.getZ());//开始二维码
//                            Short middleCode = NavigatePositionConvert.xyToPosition(middlePath.getX(), middlePath.getY(), middlePath.getZ());//中间二维码
//                            Short distCode = NavigatePositionConvert.xyToPosition(endPath.getX(), endPath.getY(), endPath.getZ());//目标二维码
//                            commands.add(getMoveCommand(startCode, distCode, allDistance, ShuttleRunDirection.get(startPath.getDirection()).id, middleCode, middleToDistDistance, runSpeed));
//                        }
//
//                        //托盘下降
//                        commands.add(getPalletCommand((short) 2));
//                    }
//
//                    if (firstMastResult == null || secMastResult == null) {
//                        throw new CoolException(MessageFormat.format( "四向穿梭车出入库路径搜索失败 ===>> [id:{0}] [ip:{1}] [port:{2}]", slave.getId(), slave.getIp(), slave.getPort()));
//                    }
//
//                    navigateMapData = new NavigateMapData(Utils.getLev(currentLocMast.getLocNo()));
//                    //所使用的路径进行锁定禁用
//                    navigateMapData.writeNavigateNodeToRedisMap(firstMastResult, true);////所使用的路径进行锁定禁用
//                    navigateMapData.writeNavigateNodeToRedisMap(secMastResult, true);////所使用的路径进行锁定禁用
//                    break;
//                case 3://托盘顶升
//                case 4://托盘下降
//                    commands.add(getPalletCommand(assignCommand.getTaskMode() == 3 ? (short) 1 : (short) 2));
//                    break;
//                case 5://强制左移
//                    commands.add(getForceMoveCommand((short) 2));
//                    break;
//                case 6://强制右移
//                    commands.add(getForceMoveCommand((short) 1));
//                    break;
//                case 7://强制上移
//                    commands.add(getForceMoveCommand((short) 3));
//                    break;
//                case 8://强制下移
//                    commands.add(getForceMoveCommand((short) 4));
//                    break;
//                case 9://状态复位
//                    ShuttleCommand reset = getResetCommand();
//                    commands.add(reset);
//                    break;
//                case 10://正方向(右)寻库位
//                    commands.add(getFindLocCommand((short) 1));
//                    break;
//                case 11://负方向(左)寻库位
//                    commands.add(getFindLocCommand((short) 2));
//                    break;
//                case 12://向正方向(前)寻库位
//                    commands.add(getFindLocCommand((short) 4));
//                    break;
//                case 13://向负方向(后)寻库位
//                    commands.add(getFindLocCommand((short) 3));
//                    break;
//                case 14://移动到目标库位
//                    String startQr = shuttleProtocol.getCurrentCode().toString();//起始位置
//                    //如果穿梭车在提升机内，移动时需要先下发出提升机命令
//                    if (liftProtocol.getBarcode().intValue() == shuttleProtocol.getCurrentCode().intValue()) {
//                        //穿梭车出提升机
//                        Short liftArrival = liftProtocol.getPositionArrivalFeedback();//提升机位置反馈
//                        String liftSiteLocNo = Utils.liftArrivalToOutInStaLocNo(liftArrival);
//                        LocMast locMast1 = locMastService.selectById(liftSiteLocNo);
//                        ShuttleCommand moveCommand = getMoveCommand(liftProtocol.getBarcode(), Short.parseShort(locMast1.getQrCodeValue()), 1600, ShuttleRunDirection.BOTTOM.id, null, null, runSpeed);
//                        commands.add(moveCommand);
//
//                        //起始位置修改为提升机口站点位置
//                        startQr = locMast1.getQrCodeValue();
//                    }
//
//                    LocMast locMast = locMastService.queryByQrCode(startQr);
//                    List<NavigateNode> result = NavigateUtils.calc(locMast.getLocNo(), assignCommand.getLocNo(), NavigationMapType.NONE.id, Utils.getShuttlePoints(assignCommand.getShuttleNo().intValue(), Utils.getLev(locMast.getLocNo())));//手动命令-移动命令，使用无过滤地图
//                    boolean checkResult3 = Utils.checkShuttlePath(result, shuttleProtocol.getShuttleNo().intValue());
//                    if (result != null && checkResult3) {
//                        //所使用的路径进行锁定禁用
//                        navigateMapData = new NavigateMapData(Utils.getLev(locMast.getLocNo()));
//                        navigateMapData.writeNavigateNodeToRedisMap(result, true);////所使用的路径进行锁定禁用
//
//                        allNode.addAll(result);//将节点进行保存
//                        //获取分段路径
//                        ArrayList<ArrayList<NavigateNode>> data = NavigateUtils.getSectionPath(result);
//                        //将每一段路径分成command指令
//                        for (ArrayList<NavigateNode> nodes : data) {
//                            //开始路径
//                            NavigateNode startPath = nodes.get(0);
//                            //中间路径
//                            NavigateNode middlePath = nodes.get(nodes.size() - 2);
//                            //目标路径
//                            NavigateNode endPath = nodes.get(nodes.size() - 1);
//                            Integer allDistance = NavigateUtils.getCurrentPathAllDistance(nodes);//计算当前路径行走总距离
//                            Integer middleToDistDistance = NavigateUtils.getMiddleToDistDistance(nodes, middlePath);//计算中间点到目标点行走距离
//                            Short startCode = NavigatePositionConvert.xyToPosition(startPath.getX(), startPath.getY(), startPath.getZ());//开始二维码
//                            Short middleCode = NavigatePositionConvert.xyToPosition(middlePath.getX(), middlePath.getY(), middlePath.getZ());//中间二维码
//                            Short distCode = NavigatePositionConvert.xyToPosition(endPath.getX(), endPath.getY(), endPath.getZ());//目标二维码
//                            //正常移动命令
//                            commands.add(getMoveCommand(startCode, distCode, allDistance, ShuttleRunDirection.get(startPath.getDirection()).id, middleCode, middleToDistDistance, runSpeed));
//                        }
//                    }
//                    break;
//                case 15://充电开关
//                    commands.add(getChargeSwitchCommand());
//                    break;
//                case 16://移动到提升机
//                    LocMast locMast1 = locMastService.queryByQrCode(shuttleProtocol.getCurrentCode().toString());
//                    int lev = Utils.getLev(locMast1.getLocNo());//穿梭车当前高度
//                    String liftSiteLocNo = Utils.levToOutInStaLocNo(lev);//当前楼层站点库位号
//                    LocMast liftSitelocMast = locMastService.selectById(liftSiteLocNo);
//                    List<NavigateNode> result1 = NavigateUtils.calc(locMast1.getLocNo(), liftSiteLocNo, NavigationMapType.NONE.id, Utils.getShuttlePoints(assignCommand.getShuttleNo().intValue(), Utils.getLev(locMast1.getLocNo())));//移动到提升机，使用无过滤地图
//                    boolean checkResult4 = Utils.checkShuttlePath(result1, shuttleProtocol.getShuttleNo().intValue());
//                    Short endStartCode = null;
//                    if (result1 != null && checkResult4) {
//                        //所使用的路径进行锁定禁用
//                        navigateMapData = new NavigateMapData(Utils.getLev(locMast1.getLocNo()));
//                        navigateMapData.writeNavigateNodeToRedisMap(result1, true);////所使用的路径进行锁定禁用
//
//                        allNode.addAll(result1);//将节点进行保存
//                        //获取分段路径
//                        ArrayList<ArrayList<NavigateNode>> data = NavigateUtils.getSectionPath(result1);
//                        //将每一段路径分成command指令
//                        for (ArrayList<NavigateNode> nodes : data) {
//                            //开始路径
//                            NavigateNode startPath = nodes.get(0);
//                            //中间路径
//                            NavigateNode middlePath = nodes.get(nodes.size() - 2);
//                            //目标路径
//                            NavigateNode endPath = nodes.get(nodes.size() - 1);
//                            Integer allDistance = NavigateUtils.getCurrentPathAllDistance(nodes);//计算当前路径行走总距离
//                            Integer middleToDistDistance = NavigateUtils.getMiddleToDistDistance(nodes, middlePath);//计算中间点到目标点行走距离
//                            Short startCode = NavigatePositionConvert.xyToPosition(startPath.getX(), startPath.getY(), startPath.getZ());//开始二维码
//                            Short middleCode = NavigatePositionConvert.xyToPosition(middlePath.getX(), middlePath.getY(), middlePath.getZ());//中间二维码
//                            Short distCode = NavigatePositionConvert.xyToPosition(endPath.getX(), endPath.getY(), endPath.getZ());//目标二维码
//                            endStartCode = distCode;
//                            //正常移动命令
//                            commands.add(getMoveCommand(startCode, distCode, allDistance, ShuttleRunDirection.get(startPath.getDirection()).id, middleCode, middleToDistDistance, runSpeed));
//                        }
//                    }
//
//                    if (endStartCode == null && shuttleProtocol.getCurrentCode() == Short.parseShort(liftSitelocMast.getQrCodeValue())) {
//                        //穿梭车已经在提升机站点口
//                        endStartCode = shuttleProtocol.getCurrentCode();
//                    }
//
//                    //增加移动进提升机命令
//                    ShuttleCommand moveCommand = getMoveCommand(endStartCode, liftProtocol.getBarcode(), 1600, ShuttleRunDirection.TOP.id, null, null, runSpeed);
//                    commands.add(moveCommand);
//                    break;
//                default:
//            }
//            assignCommand.setCommands(commands);
//            assignCommand.setNodes(allNode);//当前任务所占用的节点list
//        }
//
//        redisCommand.setShuttleNo(assignCommand.getShuttleNo());//四向穿梭车号
//        redisCommand.setWrkNo(assignCommand.getTaskNo());//工作号
//        redisCommand.setCommandStep(0);//命令执行步序
//        redisCommand.setAssignCommand(assignCommand);//命令
//        redisCommand.setErrorCommands(new ArrayList<ShuttleCommand>());//发生错误时尝试执行的指令，优先级最高
//        shuttleProtocol.setTaskNo(assignCommand.getTaskNo());
//        shuttleProtocol.setAssignCommand(assignCommand);
//        shuttleProtocol.setProtocolStatus(ShuttleProtocolStatusType.WORKING);
//        //任务数据保存到redis
//        redisUtil.set("shuttle_wrk_no_" + assignCommand.getTaskNo(), JSON.toJSONString(redisCommand));
//        //执行下发任务
//        executeWork(assignCommand.getTaskNo());
        ShuttleRedisCommand redisCommand = new ShuttleRedisCommand();
        redisCommand.setShuttleNo(assignCommand.getShuttleNo());//四向穿梭车号
        redisCommand.setWrkNo(assignCommand.getTaskNo());//工作号
        redisCommand.setCommandStep(0);//命令执行步序
        redisCommand.setAssignCommand(assignCommand);//命令
        shuttleProtocol.setTaskNo(assignCommand.getTaskNo().intValue());
        shuttleProtocol.setAssignCommand(assignCommand);
        shuttleProtocol.setProtocolStatus(ShuttleProtocolStatusType.WORKING);
        //任务数据保存到redis
        redisUtil.set(RedisKeyType.SHUTTLE.key + assignCommand.getTaskNo(), JSON.toJSONString(redisCommand));
        //执行下发任务
        executeWork(assignCommand.getTaskNo());
    }

    //执行下发的指令
    private boolean executeWork(Integer wrkNo) {
//        //读取redis数据
//        if (wrkNo == null) {
    private boolean executeWork(Short wrkNo) {
        //读取redis数据
        if (wrkNo == null) {
            return false;
        }

        NavigateMapUtils navigateMapUtils = SpringUtils.getBean(NavigateMapUtils.class);
        WrkMastMapper wrkMastMapper = SpringUtils.getBean(WrkMastMapper.class);
        WrkMast wrkMast = wrkMastMapper.selectByWorkNo(wrkNo.intValue());

        Object o = redisUtil.get(RedisKeyType.SHUTTLE.key + wrkNo);
        if (o == null) {
            return false;
        }

        ShuttleRedisCommand redisCommand = JSON.parseObject(o.toString(), ShuttleRedisCommand.class);
        ShuttleAssignCommand assignCommand = redisCommand.getAssignCommand();
        List<NyShuttleHttpCommand> commands = redisCommand.getAssignCommand().getCommands();
        //当前步序
        int commandStep = redisCommand.getCommandStep();
        if (commands.size() == 0) {
            return false;
        }

        checkIOSta(commands, commandStep);//检测小车是否进出提升机输送站

        boolean isLock = false;//是否解锁路径
        //取出命令
        NyShuttleHttpCommand command = null;
        if (commandStep < commands.size()) {
            command = commands.get(commandStep);//当前命令
        }
        if (commandStep != 0) {
            //判断上一条指令是否完成
            NyShuttleHttpCommand lastCommand = commands.get(commandStep - 1);
            String requestType = lastCommand.getRequest().getBody().get("requestType").toString();
            if (requestType.equals("move") || requestType.equals("intoLift") || requestType.equals("outLift")) {
                //移动命令、出入提升机命令
                NyShuttleProtocol.NyShuttlePointClass target = JSON.parseObject(lastCommand.getRequest().getBody().get("target").toString(), NyShuttleProtocol.NyShuttlePointClass.class);
                if (shuttleProtocol.getPoint().equals(target)) {
                    //上一条指令的目标位置和当前小车位置相同，则认定上一条任务完成
                    lastCommand.setComplete(true);
                    //解锁锁定路径，上一条路径
                    List<NavigateNode> nodes = JSON.parseArray(JSON.toJSONString(lastCommand.getNodes()), NavigateNode.class);//进行深度copy
//                    //解锁当前路径
//                    if (command != null && command.getNodes() != null) {
//                        nodes.addAll(command.getNodes());
//                    }
                    if (nodes != null) {
                        NavigateNode targetNode = assignCommand.getNodes().get(assignCommand.getNodes().size() - 1);//最终节点
                        NavigateNode node = nodes.get(nodes.size() - 1);
                        if (!(targetNode.getX() == node.getX() && targetNode.getY() == node.getY())) {
                            nodes.remove(nodes.size() - 1);//剔除尾节点
                        }
                        boolean result = navigateMapUtils.writeNavigateNodeToRedisMap(Utils.getLev(shuttleProtocol.getCurrentLocNo()), nodes, false);//解锁路径
                        if (!result) {
                            return false;//解锁失败
                        }
                        isLock = true;//解锁过路径
                    }
                }
            }else {
                lastCommand.setComplete(true);//其他命令默认认为完成
            }
            //任务数据保存到redis
            redisUtil.set(RedisKeyType.SHUTTLE.key + redisCommand.getWrkNo(), JSON.toJSONString(redisCommand));

            if (!lastCommand.getComplete()) {
                //上一条任务未完成，禁止下发命令
                return false;
            }

            //判断是否为最后一条命令且命令执行完成，抛出等待确认状态
            NyShuttleHttpCommand endCommand = commands.get(commands.size() - 1);
            if (endCommand.getComplete()) {
                //删除redis
                redisUtil.del(RedisKeyType.SHUTTLE.key + redisCommand.getWrkNo());

                if (!assignCommand.getCharge()) {
                    //对主线程抛出等待确认状态waiting
                    shuttleProtocol.setProtocolStatus(ShuttleProtocolStatusType.WAITING);
                }else {
                    shuttleProtocol.setProtocolStatus(ShuttleProtocolStatusType.CHARGING_WAITING);
                }
                News.info("四向穿梭车任务执行下发完成等待执行结束，穿梭车号={}，任务数据={}", shuttleProtocol.getShuttleNo(), JSON.toJSON(commands));

                return false;//禁止再下发命令
            }
        }

        List<NavigateNode> nextNodes = null;//下一步命令行走路径
        if (commandStep + 1 < commands.size()) {
            NyShuttleHttpCommand nextCommand = commands.get(commandStep + 1);//下一步命令
            nextNodes = nextCommand.getNodes();//下一步命令行走路径
        }

        if (shuttleProtocol.getFree() == ShuttleStatusType.BUSY.id) {
            String requestType = command.getRequest().getBody().get("requestType").toString();
            //停止充电 管制命令
            if(!(requestType.equals("stopCharge") && shuttleProtocol.getChargState() == 1) && !requestType.equals("resume")){
                return false;//小车状态忙，禁止执行命令
            }
        }

//        //检测小车是否要进提升机，如需要进提升机则调度提升机
//        if (!checkLiftStation(wrkNo)) {
//            return false;
//        }
//
//        WrkMastService wrkMastService = SpringUtils.getBean(WrkMastService.class);
//
//        Object o = redisUtil.get("shuttle_wrk_no_" + wrkNo);
//        if (o == null) {
//            return false;
//        }
//        ShuttleRedisCommand redisCommand = JSON.parseObject(o.toString(), ShuttleRedisCommand.class);
//
//        if (shuttleProtocol.getBusyStatus().intValue() == ShuttleStatusType.BUSY.id) {
//            return false;//小车状态忙
//        }
//
//        if (!checkLiftStation(wrkNo)) {//检测是否有提升机站点，有则调度提升机
//            return false;
//        }
//
//        LiftThread liftThread = (LiftThread) SlaveConnection.get(SlaveType.Lift, 1);
//        LiftProtocol liftProtocol = liftThread.getLiftProtocol();
//
//        List<ShuttleCommand> commands = redisCommand.getAssignCommand().getCommands();
//        //当前步序
//        int commandStep = redisCommand.getCommandStep();
//        //path路径数目
//        int size = commands.size();
//        ShuttleAssignCommand assignCommand = redisCommand.getAssignCommand();
//
//        if (commandStep != 0) {
//            //判断上一条指令是否完成
//            ShuttleCommand command = commands.get(commandStep - 1);
//            if (command.getCommandWord().intValue() == 1) {
//                //移动命令
//                if (command.getDistCodeNum().intValue() == shuttleProtocol.getCurrentCode().intValue()) {
//                    //上一条指令的目标位置和当前小车位置相同，则认定上一条任务完成
//                    command.setComplete(true);
//
//                    //上一条指令起点是提升机二维码，则清零提升机任务号
//                    if (command.getStartCodeNum().intValue() == liftProtocol.getBarcode().intValue()) {
//                        //判断提升机是否处于空闲
//                        if (liftProtocol.isIdleNoTask() && liftProtocol.getTaskNo().intValue() == redisCommand.getWrkNo().intValue()) {
//                            liftProtocol.setTaskNo((short) 0);//清空任务号
//                            WrkMast wrkMast = wrkMastService.selectById(wrkNo);
//                            if (wrkMast != null) {
//                                wrkMast.setLiftNo(null);//解锁提升机
//                                wrkMastService.updateById(wrkMast);
//                            }
//                        }
//                    }
//
//                    //入库命令，当小车取完货后，需要将提升机释放
//                    if (assignCommand.getTaskMode().intValue() == ShuttleTaskModeType.PAK_IN.id) {
//                        //判断上一条指令的起点是否为输送站点且目标点不是提升机内部二维码
//                        Short startCodeNum = command.getStartCodeNum();
//                        BasDevpService basDevpService = SpringUtils.getBean(BasDevpService.class);
//                        BasDevp basDevp = basDevpService.queryByQrCode(startCodeNum.intValue());//目标站点
//                        if (basDevp != null && command.getDistCodeNum().intValue() != liftProtocol.getBarcode().intValue()) {
//                            //上一条指令的起点为输送站点且目标点不是提升机内部二维码
//                            //此时小车应该已经离开输送站点，判断提升机是否空闲且有工作号
//                            if (liftProtocol.isIdleNoTask() && liftProtocol.getTaskNo().intValue() == redisCommand.getWrkNo().intValue()) {
//                                liftProtocol.setTaskNo((short) 0);//清空任务号
//                                WrkMast wrkMast = wrkMastService.selectById(wrkNo);
//                                if (wrkMast != null) {
//                                    wrkMast.setLiftNo(null);//解锁提升机
//                                    wrkMastService.updateById(wrkMast);
//                                }
//                            }
//                        }
//                    }
//
//                }
//            } else if (command.getCommandWord().intValue() == 2) {
//                //托盘顶升命令
//                if (command.getPalletLift().intValue() == 1) {
//                    //顶升
//                    //判断是否顶升到位
//                    if (shuttleProtocol.getPlcOutputLift()) {
//                        //自动模式
//                        if (assignCommand.getAuto() && shuttleProtocol.getPlcInputStatus().intValue() == 1) {
//                            //顶升到位,且托盘雷达有物，认定任务完成
//                            command.setComplete(true);
//                        }else {
//                            //手动模式，不判断托盘雷达
//                            //顶升到位，认定任务完成
//                            command.setComplete(true);
//                        }
//                    }
//                }else {
//                    //下降
//                    //判断是否下降到位，判断托盘雷达是否无物
//                    if (!shuttleProtocol.getPlcOutputLift() && !shuttleProtocol.getPlcOutputTransfer()) {
//                        //自动模式
//                        if (assignCommand.getAuto() && shuttleProtocol.getPlcInputStatus().intValue() == 0) {
//                            //下降到位，且托盘雷达无物，认定任务完成
//                            command.setComplete(true);
//                        }else {
//                            //手动模式，不判断托盘雷达
//                            //下降到位，且托盘雷达无物，认定任务完成
//                            command.setComplete(true);
//                        }
//                    }
//                }
//            } else if (command.getCommandWord().intValue() == 5) {
//                //充电命令
//                //判断小车充电开关
//                if (shuttleProtocol.getPlcOutputCharge()) {
//                    //正常充电，认定任务完成
//                    command.setComplete(true);
//                }

        //检测穿梭车是否在提升机内
        if (!checkShuttleInTheLift(wrkNo)) {
            return false;
        }

//        if (command.getRequest().getBody().get("requestType").equals("move")) {
//            ArrayList<int[]> whiteList = new ArrayList<>();//设置节点的白名单
//            if (wrkMast != null && ((wrkMast.getIoType() > 100 && wrkMast.getIoType() < 200) || wrkMast.getIoType() == 11)) {
//                //出库任务，不检测首节点
//                int[] startArr = NavigatePositionConvert.positionToXY(wrkMast.getSourceLocNo());//开始节点
//                whiteList.add(startArr);
//            }
//            //任务数据保存到redis
//            redisUtil.set("shuttle_wrk_no_" + redisCommand.getWrkNo(), JSON.toJSONString(redisCommand));
//
//            if (!command.getComplete()) {
//                //上一条任务未完成，禁止下发命令
//                return false;
//            }
//        }
//
//        if (commands.size() == 0) {
//            return false;
//        }
//
//        //取出命令
//        ShuttleCommand command = commands.get(commandStep);
//
//        if (assignCommand.getTaskMode() == ShuttleTaskModeType.PAK_IN.id.shortValue()
//                || assignCommand.getTaskMode() == ShuttleTaskModeType.PAK_OUT.id.shortValue()
//        ) {
//            //小车失去坐标，禁止下发命令
//            if (shuttleProtocol.getCurrentCode() == 0) {
//                return false;
//            }
//        }
//
//
//        //判断小车当前二维码是否为提升机二维码
//        if (shuttleProtocol.getCurrentCode().intValue() == liftProtocol.getBarcode().intValue()) {
//            //小车当前命令起始位置就是提升机二维码，说明小车需要向提升机外移动，则需要判断状态是否满足
//            if (command.getStartCodeNum().intValue() == liftProtocol.getBarcode().intValue()){
//                //提升机是否空闲，提升机是否到达目标楼层，目标楼层是否给出提升机到位信号位
//                if (!liftProtocol.isIdleNoTask()) {
//                    return false;//提升机忙，禁止下发命令
//                }
//                if (liftProtocol.getTaskNo().intValue() != 0 && liftProtocol.getTaskNo().intValue() != wrkNo) {
//                    //提升机工作号和当前工作不相同，禁止下发命令
//            //解锁过路径，只检测下一段路径是否可走(当前路径已经被锁定无需再检测)
//            if (isLock) {
//                //只检测下一段路径是否可走(当前路径已经被锁定无需再检测)
//                //检测路径是否可行走
//                if (!checkPath(nextNodes == null ? command.getNodes() : nextNodes, null, whiteList)) {
//                    return false;
//                }
//
//                Short distCodeNum = command.getDistCodeNum();//目标二维码
//                BasDevpService basDevpService = SpringUtils.getBean(BasDevpService.class);
//                BasDevp basDevp = basDevpService.queryByQrCode(distCodeNum.intValue());//目标站点
//                if (basDevp == null) {
//                    return false;//找不到目标站，禁止下发命令
//                }
//
//                int lev = Utils.getLev(basDevp.getLocNo());//目标二维码所在楼层
//                int liftLev = liftProtocol.getLev().intValue();//提升机所在楼层
//                if (liftLev != lev) {
//                    return false;//提升机不在目标楼层，禁止下发命令
//                }
//
//                //获取目标站信息
//                SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, 1);
//                StaProtocol staProtocol = devpThread.getStation().get(basDevp.getDevNo());
//                if (staProtocol == null) {
//                    return false;//站点信息不存在，禁止下发命令
//                }
//                if (!staProtocol.isLiftArrival()) {
//                    return false;//站点提升机到位信号false，禁止下发命令
//                }
//
//                //条件满足，占用提升机
//                liftProtocol.setTaskNo(wrkNo);
//            }
//        }
//
//        //下发命令
//        if (!write(command)) {
//            News.error("四向穿梭车命令下发失败，穿梭车号={}，任务数据={}", shuttleProtocol.getShuttleNo(), JSON.toJSON(command));
//            return false;
//        } else {
//            News.info("四向穿梭车命令下发成功，穿梭车号={}，任务数据={}", shuttleProtocol.getShuttleNo(), JSON.toJSON(command));
//
//            //将标记置为false(防止重发)
//            shuttleProtocol.setPakMk(false);
//
//            //保存数据到数据库做流水
//            BasShuttleOptService shuttleOptService = SpringUtils.getBean(BasShuttleOptService.class);
//            if (shuttleOptService != null) {
//                short[] commandArr = getCommandArr(command);//获取命令报文
//                BasShuttleOpt opt = new BasShuttleOpt(
//                        assignCommand.getTaskNo().intValue(),
//                        assignCommand.getShuttleNo().intValue(),
//                        new Date(),
//                        ShuttleTaskModeType.get(assignCommand.getTaskMode()).desc,
//                        assignCommand.getSourceLocNo(),
//                        assignCommand.getLocNo(),
//                        null,
//                        null,
//                        null,
//                        JSON.toJSONString(command),
//                        JSON.toJSONString(commandArr)
//                );
//                shuttleOptService.insert(opt);
//            }
//
//            //判断数据是否执行完成
//            if (commandStep < size - 1) {
//                //更新redis数据
//                //步序增加
//                commandStep++;
//                redisCommand.setCommandStep(commandStep);
//                //任务数据保存到redis
//                redisUtil.set("shuttle_wrk_no_" + redisCommand.getWrkNo(), JSON.toJSONString(redisCommand));
//            }else {
//                //已执行完成
//
//                if (redisCommand.getLiftSecurityMk()) {
//                    //曾锁定过提升机，需要进行解锁
//                    if (liftProtocol != null) {
//                        liftProtocol.setSecurityMk(false);
//                    }
//                //检测当前路径和下一段路径
//                //检测路径是否可行走
//                if (!checkPath(command.getNodes(), nextNodes, whiteList)) {
//                    return false;
//                }
//
//                String locNo = shuttleProtocol.getLocNo() == null ? shuttleProtocol.getSourceLocNo() : shuttleProtocol.getLocNo();
//                if (locNo != null) {
//                    //解除锁定的库位路径
//                    NavigateMapData navigateMapData = new NavigateMapData(Utils.getLev(locNo));
//                    navigateMapData.writeNavigateNodeToRedisMap(redisCommand.getAssignCommand().getNodes(), false);
//                }
//
//                //删除redis
//                redisUtil.del("shuttle_wrk_no_" + redisCommand.getWrkNo());
//
//                if (!assignCommand.getAuto()) {
//                    //手动模式不抛出等待状态，直接复位
//                    //设置四向穿梭车为空闲状态
//                    shuttleProtocol.setProtocolStatus(ShuttleProtocolStatusType.IDLE);
//                    //任务号清零
//                    shuttleProtocol.setTaskNo((short) 0);
//                    //标记复位
//                    shuttleProtocol.setPakMk(true);
//                    News.info("四向穿梭车手动任务执行完成，穿梭车号={}，任务数据={}", shuttleProtocol.getShuttleNo(), JSON.toJSON(command));
//                }else {
//                    if (!assignCommand.getCharge()) {
//                        //对主线程抛出等待确认状态waiting
//                        shuttleProtocol.setProtocolStatus(ShuttleProtocolStatusType.WAITING);
//                    }else {
//                        shuttleProtocol.setProtocolStatus(ShuttleProtocolStatusType.CHARGING_WAITING);
//                    }
//                    News.info("四向穿梭车任务执行下发完成等待执行结束，穿梭车号={}，任务数据={}", shuttleProtocol.getShuttleNo(), JSON.toJSON(command));
//                }
//
//            }
//
//            //锁定路径，锁定当前路径和下一步路径
//            List<NavigateNode> nodes = command.getNodes();
//            if (nextNodes != null) {
//                nodes.addAll(nextNodes);
//            }
//            if (nodes != null) {
//                boolean result = navigateMapUtils.writeNavigateNodeToRedisMap(Utils.getLev(shuttleProtocol.getCurrentLocNo()), nodes, true);//所使用的路径进行锁定禁用
//                if (!result) {
//                    return false;//路径锁定失败
//                }
//            }
//        }

        //可执行命令
        if (!write(command, assignCommand)) {
            News.error("四向穿梭车命令下发失败，穿梭车号={}，任务数据={}", shuttleProtocol.getShuttleNo(), JSON.toJSON(command));
            return false;
        }

        News.info("四向穿梭车命令下发成功，穿梭车号={}，任务数据={}", shuttleProtocol.getShuttleNo(), JSON.toJSON(command));
        //将标记置为false(防止重发)
        shuttleProtocol.setPakMk(true);

        String requestType = command.getRequest().getBody().get("requestType").toString();
        if (requestType.equals("updateFloor")) {
            //更新楼层命令
            shuttleProtocol.setPakMk(false);//恢复标记
        }

        commandStep++;
        //更新redis数据
        redisCommand.setCommandStep(commandStep);
        //任务数据保存到redis
        redisUtil.set(RedisKeyType.SHUTTLE.key + redisCommand.getWrkNo(), JSON.toJSONString(redisCommand));

        return true;
    }

    //检测小车是否要进提升机，如需要进提升机则调度提升机
    private boolean checkLiftStation(Short wrkNo) {
        //读取redis数据
        if (wrkNo == null) {
            return false;
        }

        Object o = redisUtil.get(RedisKeyType.SHUTTLE.key + wrkNo);
        if (o == null) {
            return false;
        }

        WrkMastMapper wrkMastMapper = SpringUtils.getBean(WrkMastMapper.class);

        ShuttleRedisCommand redisCommand = JSON.parseObject(o.toString(), ShuttleRedisCommand.class);
        //当前步序
        int commandStep = redisCommand.getCommandStep();

        //检测是否存在提升机口的指令
        List<NyShuttleHttpCommand> commands = redisCommand.getAssignCommand().getCommands();
        if (commands.isEmpty()) {
            return false;
        }
        NyShuttleHttpCommand command = commands.get(commandStep);//当前命令
        if (!command.getMsgType().equals("intoLift")) {
            return true;//不是入提升机命令，直接放行
        }

        //获取起点(输送站点)
        NyShuttleProtocol.NyShuttlePointClass start = JSON.parseObject(command.getRequest().getBody().get("start").toString(), NyShuttleProtocol.NyShuttlePointClass.class);
        //将牛眼坐标转换成WCS库位号
        String startLocNo = NavigatePositionConvert.nyXyzToLocNo(start.getX(), start.getY(), start.getZ());

        BasDevpService basDevpService = SpringUtils.getBean(BasDevpService.class);
        BasDevp basDevp = basDevpService.queryByLocNo(startLocNo);
        if (basDevp == null) {
            return false;//查不到站点，禁止下发
        }

        //拿到提升机线程
        LiftThread liftThread = (LiftThread) SlaveConnection.get(SlaveType.Lift, basDevp.getLiftNo());
        if (liftThread == null) {
            return false;
        }
        LiftProtocol liftProtocol = liftThread.getLiftProtocol();
        if (liftProtocol == null) {
            return false;
        }
        if (!liftProtocol.isIdle()) {
            return false;
        }

        if (liftProtocol.getLev().intValue() == Utils.getLev(shuttleProtocol.getCurrentLocNo())) {
            return true;//提升机达到小车楼层，放行
        }

        //搜索是否有其他任务占用了提升机，如果占用提升机的任务和当前任务相同，则运行执行
        WrkMast wrkMast1 = wrkMastMapper.selectLiftWrkMast(liftProtocol.getLiftNo().intValue());
        if (wrkMast1 != null && wrkMast1.getWrkNo() != wrkNo.intValue()) {
            return false;
        }

        //提升机未到达小车楼层，呼叫提升机
        //获取提升机命令
        NyLiftCommand liftCommand = NyLiftUtils.getLiftCommand(liftProtocol.getLiftNo().intValue(), NyLiftTaskModelType.MOVE_CAR.id, null, basDevp.getDevNo(), wrkNo.intValue());
        ArrayList<NyLiftCommand> liftCommands = new ArrayList<>();
        liftCommands.add(liftCommand);

        //提交到线程去工作
        LiftAssignCommand assignCommand = new LiftAssignCommand();
        assignCommand.setCommands(liftCommands);
        assignCommand.setLiftNo(liftProtocol.getLiftNo());
        assignCommand.setTaskNo(wrkNo);
        assignCommand.setTaskMode(NyLiftTaskModelType.MOVE_CAR.id.shortValue());

        //下发任务
        MessageQueue.offer(SlaveType.Lift, liftProtocol.getLiftNo().intValue(), new Task(3, assignCommand));

        return false;//默认不放行
    }

    /**
     * 检测穿梭车是否在提升机内
     * 如穿梭车在提升机内，必须等待提升机空闲才可执行穿梭车命令
     */
    private boolean checkShuttleInTheLift(Short wrkNo) {
        //读取redis数据
        if (wrkNo == null) {
            return false;
        }

        Object o = redisUtil.get(RedisKeyType.SHUTTLE.key + wrkNo);
        if (o == null) {
            return false;
        }

        SlaveProperties slaveProperties = SpringUtils.getBean(SlaveProperties.class);
        BasLiftService liftService = SpringUtils.getBean(BasLiftService.class);
        for (LiftSlave liftSlave : slaveProperties.getLift()) {
            BasLift basLift = liftService.selectById(liftSlave.getId());
            if (basLift == null) {
                continue;
            }
            Integer liftX = basLift.getPoint$().getX();
            Integer liftY = basLift.getPoint$().getY();
            if (liftX.equals(shuttleProtocol.getPoint().getX()) && liftY.equals(shuttleProtocol.getPoint().getY())) {
                //小车在提升机内
                //判断提升机是否空闲
                LiftThread liftThread = (LiftThread) SlaveConnection.get(SlaveType.Lift, liftSlave.getId());
                if (liftThread == null) {
                    return false;
                }
                LiftProtocol liftProtocol = liftThread.getLiftProtocol();
                if (liftProtocol == null) {
                    return false;
                }
                if (liftProtocol.isIdle()) {
                    //提升机处于空闲，放行
                    return true;
                }
            }else {
                return true;//不在提升机内，放行
            }
        }
        return false;//默认不放行
    }

    /**
     * 检测路径是否可行走
     * 如果路径为目标库位，但不可行走，系统将尝试重新计算路径
     */
    private boolean checkPath(List<NavigateNode> currentNodes, List<NavigateNode> nextNodes, List<int[]> whitePoints) {
        //检测路径是否可行走(检查路径锁定状态，检测路径是否有其他小车)
        //检测当前行走路径，和下一步路径
        boolean checkPathIsAvailable = NavigateUtils.checkPathIsAvailable(currentNodes, shuttleProtocol.getShuttleNo().intValue(), Utils.getLev(shuttleProtocol.getCurrentLocNo()), whitePoints);
        if (nextNodes == null) {
            if (checkPathIsAvailable) {
                return true;//可行走
            }
            return false;
        }else {
            boolean checkPathIsAvailable2 = NavigateUtils.checkPathIsAvailable(nextNodes, shuttleProtocol.getShuttleNo().intValue(), Utils.getLev(shuttleProtocol.getCurrentLocNo()), whitePoints);
            if (checkPathIsAvailable && checkPathIsAvailable2) {
                return true;//可行走
            }
        }

//        ShuttleAssignCommand assignCommand = redisCommand.getAssignCommand();
//        NavigateNode currentTarget = currentNodes.get(currentNodes.size() - 1);
//        String currentLocNo = NavigatePositionConvert.nodeToLocNo(currentTarget);
//        NavigateNode nextTarget = nextNodes.get(nextNodes.size() - 1);
//        String nextLocNo = NavigatePositionConvert.nodeToLocNo(nextTarget);
//        if (assignCommand.getLocNo().equals(currentLocNo) || assignCommand.getLocNo().equals(nextLocNo)) {
//            //当前路径最后一个节点是目标库位，进行路径检测，如果不可行走，重新计算路径
//            //不可行走，重新计算路径
//            NyShuttleOperaResult result = NyShuttleOperaUtils.getStartToTargetCommands(shuttleProtocol.getShuttleNo().intValue(), shuttleProtocol.getTaskNo(), shuttleProtocol.getCurrentLocNo(), assignCommand.getLocNo());
//            if (result == null) {
//                return false;//路径计算失败，不可行走
//            }
//
//            List<NyShuttleHttpCommand> newCommands = result.getCommands();//新路径
//
//            //当前步序
//            int commandStep = redisCommand.getCommandStep();
//            List<NyShuttleHttpCommand> commands = assignCommand.getCommands();
//
//            commands.remove(commandStep);//移除当前步序指令
//            if (assignCommand.getLocNo().equals(currentLocNo)) {
//                //当前路径，需要再多移除下一步指令
//                commands.remove(commandStep + 1);
//            }
//
//            //将新路径添加进指令集合
//            commands.addAll(commandStep, newCommands);
//            assignCommand.setCommands(commands);
//            redisCommand.setAssignCommand(assignCommand);
//            //任务数据保存到redis
//            redisUtil.set(RedisKeyType.SHUTTLE.key + redisCommand.getWrkNo(), JSON.toJSONString(redisCommand));
//            return false;//当前不可行走，等待下一次执行走新路径
//        }

        return false;//不可行走
    }

    /**
     * 跑库程序
     */
    private void moveLoc() {
        LocMastService locMastService = SpringUtils.getBean(LocMastService.class);
        ShuttleDispatchUtils shuttleDispatchUtils = SpringUtils.getBean(ShuttleDispatchUtils.class);
        CommonService commonService = SpringUtils.getBean(CommonService.class);
        WrkMastMapper wrkMastMapper = SpringUtils.getBean(WrkMastMapper.class);
        int lev = Utils.getLev(shuttleProtocol.getCurrentLocNo());//小车当前楼层
        if (!shuttleProtocol.isIdle()) {
            return;
        }

        WrkMast wrkMast = wrkMastMapper.selectShuttleHasMoveWorking(shuttleProtocol.getShuttleNo().intValue());
        if (wrkMast != null) {
            return;
        }

        if (shuttleProtocol.getYCurrent() > shuttleProtocol.getYTarget()) {
            //跑库结束
            shuttleProtocol.setMoveLoc(false);
            shuttleProtocol.setMoveType(0);
            shuttleProtocol.setXStart(0);
            shuttleProtocol.setXTarget(0);
            shuttleProtocol.setXCurrent(0);
            shuttleProtocol.setYStart(0);
            shuttleProtocol.setYTarget(0);
            shuttleProtocol.setYCurrent(0);
            return;
        }

        if (shuttleProtocol.getMoveType() == 0) {//跑轨道
            ArrayList<String> locs = new ArrayList<>();
            for (int i = shuttleProtocol.getXCurrent(); i <= shuttleProtocol.getXTarget(); i++) {
                String locNo = Utils.getLocNo(i, shuttleProtocol.getYCurrent(), lev);
                locs.add(locNo);
            }
            List<LocMast> locMasts = locMastService.selectEmptyLocNos(locs);
            if (locMasts.isEmpty()) {
                //空库位
                shuttleProtocol.setYCurrent(shuttleProtocol.getYCurrent() + 1);
                return;
            }

            LocMast start = locMasts.get(0);
            LocMast target = locMasts.get(locMasts.size() - 1);
            //判断小车是否在起点位置
            if (!shuttleProtocol.getCurrentLocNo().equals(start.getLocNo())) {//不在起点位置，调度去起点位置
                shuttleDispatchUtils.dispatchShuttle(commonService.getWorkNo(3), start.getLocNo());
            }else {
                //在起点位置，调度去目标位置
                if (shuttleProtocol.getCurrentLocNo().equals(target.getLocNo())) {
                    shuttleProtocol.setYCurrent(shuttleProtocol.getYCurrent() + 1);//小车和目标位置一致，跳过
                }else {
                    boolean result = shuttleDispatchUtils.dispatchShuttle(commonService.getWorkNo(3), target.getLocNo());
                    if (result) {//调度成功
                        shuttleProtocol.setYCurrent(shuttleProtocol.getYCurrent() + 1);
                    }
                }
            }
        }else {//跑库位
            Integer xCurrent = shuttleProtocol.getXCurrent();
            if (xCurrent > shuttleProtocol.getXTarget()) {//当X值大于X目标值，进行归零且Y方向+1
                shuttleProtocol.setXCurrent(shuttleProtocol.getXStart());
                shuttleProtocol.setYCurrent(shuttleProtocol.getYCurrent() + 1);
                return;
            }

            Integer yCurrent = shuttleProtocol.getYCurrent();
            String locNo = Utils.getLocNo(xCurrent, yCurrent, lev);
            LocMast target = locMastService.selectById(locNo);
            if (target == null) {
                shuttleProtocol.setXCurrent(shuttleProtocol.getXCurrent() + 1);
                return;
            }

            if (!target.getLocSts().equals("O")) {
                shuttleProtocol.setXCurrent(shuttleProtocol.getXCurrent() + 1);
                return;
            }

            //调度去目标位置
            if (shuttleProtocol.getCurrentLocNo().equals(target.getLocNo())) {
                shuttleProtocol.setXCurrent(shuttleProtocol.getXCurrent() + 1);//小车和目标位置一致，跳过
            }else {
                boolean result = shuttleDispatchUtils.dispatchShuttle(commonService.getWorkNo(3), target.getLocNo());
                if (result) {//调度成功
                    shuttleProtocol.setXCurrent(shuttleProtocol.getXCurrent() + 1);
                }
            }
        }
    }

    //检测小车是否进出提升机输送站
    public void checkIOSta(List<NyShuttleHttpCommand> commands, int commandStep) {
        if (commandStep != 0) {
            NyShuttleHttpCommand lastCommand = commands.get(commandStep - 1);//上一步命令
            if (lastCommand.getRequest().getBody().get("requestType").equals("move")) {
                //检测起点是否为提升机输送站点
                NyShuttleProtocol.NyShuttlePointClass start = JSON.parseObject(lastCommand.getRequest().getBody().get("start").toString(), NyShuttleProtocol.NyShuttlePointClass.class);
                int[] startPoint = NavigatePositionConvert.NyXyzToWCSXyz(start.getX(), start.getY(), start.getZ());
                if (startPoint[0] == 13 && (startPoint[1] == 22 || startPoint[1] == 38 || startPoint[1] == 57)) {
                    //输送站点位置

                    int liftNo;
                    if (startPoint[1] == 22) {
                        liftNo = 1;
                    } else if (startPoint[1] == 38) {
                        liftNo = 2;
                    } else {
                        liftNo = 3;
                    }

                    HashMap<String, Object> data = new HashMap<>();
                    data.put("lev", startPoint[2]);
                    data.put("status", false);//出输送站

                    //下发任务
                    MessageQueue.offer(SlaveType.Lift, liftNo, new Task(4, data));
                }
            }
        }

        if (commands.size() == commandStep) {
            return;
        }
        NyShuttleHttpCommand command = commands.get(commandStep);//当前命令
        if (command.getRequest().getBody().get("requestType").equals("move")) {
            NyShuttleProtocol.NyShuttlePointClass target = JSON.parseObject(command.getRequest().getBody().get("target").toString(), NyShuttleProtocol.NyShuttlePointClass.class);
            int[] targetPoint = NavigatePositionConvert.NyXyzToWCSXyz(target.getX(), target.getY(), target.getZ());
            //检测目标位置是否为提升机输送站点
            if (targetPoint[0] == 13 && (targetPoint[1] == 22 || targetPoint[1] == 38 || targetPoint[1] == 57)) {
                //输送站点位置

                int liftNo;
                if (targetPoint[1] == 22) {
                    liftNo = 1;
                } else if (targetPoint[1] == 38) {
                    liftNo = 2;
                } else {
                    liftNo = 3;
                }

                HashMap<String, Object> data = new HashMap<>();
                data.put("lev", targetPoint[2]);
                data.put("status", true);//进输送站

                //下发任务
                MessageQueue.offer(SlaveType.Lift, liftNo, new Task(4, data));
            }
        }
    }

}