穿梭车命令封装

Junjie

2023-07-28 4e1a8e484888b3d3f28dc9629904e6e54d90ebc5

穿梭车命令封装

 src/main/java/com/zy/asrs/controller/ShuttleController.java

@@ -15,7 +15,10 @@
import com.zy.asrs.service.LocMastService;
import com.zy.asrs.service.WrkMastService;
import com.zy.asrs.utils.Utils;
import com.zy.common.model.NyShuttleOperaResult;
import com.zy.common.service.CommonService;
import com.zy.common.utils.NyHttpUtils;
import com.zy.common.utils.NyShuttleOperaUtils;
import com.zy.common.utils.RedisUtil;
import com.zy.core.cache.MessageQueue;
import com.zy.core.cache.OutputQueue;
@@ -23,8 +26,8 @@
import com.zy.core.enums.*;
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.ShuttleRedisCommand;
import com.zy.core.model.protocol.NyShuttleProtocol;
import com.zy.core.model.protocol.ShuttleProtocol;
@@ -184,8 +187,8 @@
        }
        ShuttleRedisCommand redisCommand = JSON.parseObject(o.toString(), ShuttleRedisCommand.class);
        ShuttleAssignCommand assignCommand = redisCommand.getAssignCommand();
        List<ShuttleCommand> commands = assignCommand.getCommands();
        ShuttleCommand command = commands.get(commandStep);
        List<NyShuttleHttpCommand> commands = assignCommand.getCommands();
        NyShuttleHttpCommand command = commands.get(commandStep);
        command.setComplete(complete != 0);
        redisUtil.set("shuttle_wrk_no_" + wrkNo, JSON.toJSONString(redisCommand));
        return R.ok();
@@ -266,6 +269,52 @@
                assignCommand.setTaskNo((short) commonService.getWorkNo(3));//获取任务号
                assignCommand.setAuto(false);//手动模式

                if (shuttleTaskModeType == ShuttleTaskModeType.TRANSPORT) {
                    //搬运货物任务
                    NyShuttleOperaResult result = NyShuttleOperaUtils.getShuttleTransportCommands(shuttleSlave.getId(), assignCommand.getTaskNo().intValue(), shuttleProtocol.getCurrentLocNo(), param.getSourceLocNo(), param.getDistLocNo());
                    if (result == null) {
                        throw new CoolException("路径计算失败");
                    }

                    assignCommand.setCommands(result.getCommands());
                    assignCommand.setNodes(result.getNodes());
                } else if (shuttleTaskModeType == ShuttleTaskModeType.MOVE_LOC_NO) {
                    //移动到目标库位
                    NyShuttleOperaResult result = NyShuttleOperaUtils.getStartToTargetCommands(shuttleSlave.getId(), assignCommand.getTaskNo().intValue(), shuttleProtocol.getCurrentLocNo(), param.getDistLocNo());
                    if (result == null) {
                        throw new CoolException("路径计算失败");
                    }

                    assignCommand.setCommands(result.getCommands());
                    assignCommand.setNodes(result.getNodes());
                } else if (shuttleTaskModeType == ShuttleTaskModeType.PALLET_LIFT) {
                    //托盘顶升
                    NyShuttleHttpCommand command = NyHttpUtils.getPalletLiftCommand(shuttleSlave.getId(), assignCommand.getTaskNo().intValue(), true);
                    ArrayList<NyShuttleHttpCommand> commands = new ArrayList<>();
                    commands.add(command);
                    assignCommand.setCommands(commands);
                } else if (shuttleTaskModeType == ShuttleTaskModeType.PALLET_DOWN) {
                    //托盘下降
                    NyShuttleHttpCommand command = NyHttpUtils.getPalletLiftCommand(shuttleSlave.getId(), assignCommand.getTaskNo().intValue(), false);
                    ArrayList<NyShuttleHttpCommand> commands = new ArrayList<>();
                    commands.add(command);
                    assignCommand.setCommands(commands);
                } else if (shuttleTaskModeType == ShuttleTaskModeType.CHARGE) {
                    //充电开关
                    NyShuttleHttpCommand command = NyHttpUtils.getChargeCommand(shuttleSlave.getId(), assignCommand.getTaskNo().intValue(), true);
                    ArrayList<NyShuttleHttpCommand> commands = new ArrayList<>();
                    commands.add(command);
                    assignCommand.setCommands(commands);
                } else if (shuttleTaskModeType == ShuttleTaskModeType.RESET) {
                    //复位
                    shuttleProtocol.setTaskNo(0);//工作号清空
                    shuttleProtocol.setProtocolStatus(ShuttleProtocolStatusType.IDLE);//任务状态-空闲
                    shuttleProtocol.setPakMk(true);//作业标记复位
                    return R.ok();
                } else {
                    throw new CoolException("未知命令");
                }

                if (MessageQueue.offer(SlaveType.Shuttle, shuttleSlave.getId(), new Task(3, assignCommand))) {
                    return R.ok();
                } else {

 src/main/java/com/zy/asrs/entity/BasShuttle.java

@@ -243,13 +243,13 @@
//    @ApiModelProperty(value= "当前的行走伺服负载率")
////    @TableField("current_move_servo_load")
//    private Integer currentMoveServoLoad;
//
//    /**
//     * 小车运行速度
//     */
//    @ApiModelProperty(value= "小车运行速度")
////    @TableField("run_speed")
//    private Integer runSpeed;

    /**
     * 小车运行速度
     */
    @ApiModelProperty(value= "小车运行速度")
    @TableField("run_speed")
    private Integer runSpeed;

    /**
     * 牛眼-工作模式

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

@@ -785,7 +785,7 @@
                                    if (commands == null) {
                                        continue;//找不到路径等待下一次
                                    }
                                    assignCommand.setCommands(commands);
//                                    assignCommand.setCommands(commands);
                                    //分配目标库位
                                    shuttleProtocol.setLocNo(wrkMast.getLocNo());
                                    //目标库位
@@ -811,7 +811,7 @@
                                    shuttleProtocol.setLocNo(liftSiteLocNo);
                                    //目标库位
                                    assignCommand.setLocNo(liftSiteLocNo);
                                    assignCommand.setCommands(commands);
//                                    assignCommand.setCommands(commands);
                                    wrkMast.setWrkSts(5L);//小车迁移状态
                                }
                            } else if (wrkMast.getWrkSts() == 8) {
@@ -832,7 +832,7 @@
                                ShuttleCommand moveCommand = shuttleThread.getMoveCommand(startCode, distCode, 1600, runDirection, null, null, 500);
                                commands.add(0, moveCommand);//将该指令添加到队头

                                assignCommand.setCommands(commands);
//                                assignCommand.setCommands(commands);
                                //分配目标库位
                                shuttleProtocol.setLocNo(wrkMast.getLocNo());
                                //目标库位
@@ -1240,7 +1240,7 @@
                            shuttleProtocol.setSourceLocNo(currentLocNo);
                            //目标库位
                            assignCommand.setLocNo(wrkMast.getSourceLocNo());
                            assignCommand.setCommands(commands);
//                            assignCommand.setCommands(commands);
                            wrkMast.setWrkSts(26L);//小车搬运中

                            if (wrkMastMapper.updateById(wrkMast) > 0) {
@@ -1274,7 +1274,7 @@

                            //目标库位
                            assignCommand.setLocNo(liftSiteLocNo);
                            assignCommand.setCommands(commands);
//                            assignCommand.setCommands(commands);
                            wrkMast.setWrkSts(22L);//小车迁移状态

                            if (wrkMastMapper.updateById(wrkMast) > 0) {
@@ -1321,7 +1321,7 @@
                        shuttleProtocol.setSourceLocNo(liftSiteLocNo);
                        //目标库位
                        assignCommand.setLocNo(wrkMast.getSourceLocNo());
                        assignCommand.setCommands(commands);
//                        assignCommand.setCommands(commands);
                        wrkMast.setWrkSts(26L);//小车搬运中

                        if (wrkMastMapper.updateById(wrkMast) > 0) {
@@ -1872,7 +1872,7 @@

                //所需命令组合完毕，更新数据库，提交到线程去工作
                LiftAssignCommand assignCommand = new LiftAssignCommand();
                assignCommand.setCommands(commands);
//                assignCommand.setCommands(commands);
                assignCommand.setLiftNo(liftProtocol.getLiftNo());
                assignCommand.setTaskNo(liftProtocol.getTaskNo());
                if (wrkMastMapper.updateById(wrkMast) > 0) {
@@ -2126,7 +2126,7 @@
                shuttleProtocol.setLocNo(liftSiteLocNo);
                //目标库位
                assignCommand.setLocNo(liftSiteLocNo);
                assignCommand.setCommands(commands);
//                assignCommand.setCommands(commands);
                wrkMast.setWrkSts(5L);//小车迁移状态

                if (wrkMastMapper.updateById(wrkMast) > 0) {
@@ -2233,7 +2233,7 @@
            //分配源库位
            shuttleProtocol.setSourceLocNo(wrkMast.getSourceLocNo());

            assignCommand.setCommands(commands);
//            assignCommand.setCommands(commands);
            //分配目标库位
            shuttleProtocol.setLocNo(wrkMast.getLocNo());
            //目标库位
@@ -2751,7 +2751,7 @@
                    commands.add(command);

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

                    wrkCharge.setWrkSts(56L);//充电中状态
                    if (wrkChargeMapper.updateById(wrkCharge) > 0) {
@@ -2793,7 +2793,7 @@
                    assignCommand.setLocNo(chargeLocNo);
                    //源库位
                    assignCommand.setSourceLocNo(currentLocNo);
                    assignCommand.setCommands(commands);
//                    assignCommand.setCommands(commands);
                    wrkCharge.setWrkSts(52L);//小车迁移状态
                    if (wrkChargeMapper.updateById(wrkCharge) > 0) {
                        //下发任务
@@ -2831,7 +2831,7 @@
                wrkCharge.setWrkSts(54L);//提升机搬运中
                //所需命令组合完毕，更新数据库，提交到线程去工作
                LiftAssignCommand assignCommand = new LiftAssignCommand();
                assignCommand.setCommands(commands);
//                assignCommand.setCommands(commands);
                assignCommand.setLiftNo(liftProtocol.getLiftNo());
                assignCommand.setTaskNo(liftProtocol.getTaskNo());
                if (wrkChargeMapper.updateById(wrkCharge) > 0) {
@@ -2886,7 +2886,7 @@
                commands.add(command);

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

                wrkCharge.setWrkSts(56L);//充电中状态
                if (wrkChargeMapper.updateById(wrkCharge) > 0) {

 src/main/java/com/zy/asrs/utils/Utils.java

@@ -23,8 +23,10 @@
import com.zy.core.model.Task;
import com.zy.core.model.command.ShuttleAssignCommand;
import com.zy.core.model.command.ShuttleCommand;
import com.zy.core.model.protocol.NyShuttleProtocol;
import com.zy.core.model.protocol.ShuttleProtocol;
import com.zy.core.properties.SlaveProperties;
import com.zy.core.thread.NyShuttleThread;
import com.zy.core.thread.ShuttleThread;

import java.text.DecimalFormat;
@@ -420,24 +422,24 @@
            }

            //获取穿梭车所在节点位置
            ShuttleThread shuttleThread = (ShuttleThread) SlaveConnection.get(SlaveType.Shuttle, slave.getId());
            NyShuttleThread shuttleThread = (NyShuttleThread) SlaveConnection.get(SlaveType.Shuttle, slave.getId());
            if (shuttleThread == null) {
                continue;
            }
            ShuttleProtocol shuttleProtocol = shuttleThread.getShuttleProtocol();
            NyShuttleProtocol shuttleProtocol = shuttleThread.getShuttleProtocol();
            if (shuttleProtocol == null) {
                continue;
            }

            if (shuttleProtocol.getLocNo() == null) {
            if (shuttleProtocol.getCurrentLocNo() == null) {
                continue;
            }

            if (lev != Utils.getLev(shuttleProtocol.getLocNo())) {
            if (lev != Utils.getLev(shuttleProtocol.getCurrentLocNo())) {
                continue;//楼层不同
            }

            int[] xyPosition = NavigatePositionConvert.positionToXY(shuttleProtocol.getLocNo());//通过库位号获取xy坐标
            int[] xyPosition = NavigatePositionConvert.positionToXY(shuttleProtocol.getCurrentLocNo());//通过库位号获取xy坐标
            list.add(xyPosition);
        }
        return list;
@@ -601,7 +603,7 @@
                return null;
            }

            assignCommand.setCommands(commands);
//            assignCommand.setCommands(commands);
            return assignCommand;
        }
        return null;

 src/main/java/com/zy/common/model/NyShuttleOperaResult.java

New file
@@ -0,0 +1,20 @@
package com.zy.common.model;

import com.zy.core.model.command.NyShuttleHttpCommand;
import lombok.Data;

import java.util.List;

@Data
//结果集
public class NyShuttleOperaResult {
    //命令集合
    private List<NyShuttleHttpCommand> commands;
    //行走路径集合
    private List<NavigateNode> nodes;

    public NyShuttleOperaResult(List<NyShuttleHttpCommand> commands, List<NavigateNode> nodes) {
        this.commands = commands;
        this.nodes = nodes;
    }
}

 src/main/java/com/zy/common/utils/NyHttpUtils.java

@@ -4,6 +4,8 @@
import com.alibaba.fastjson.JSONObject;
import com.zy.common.model.NavigateNode;
import com.zy.core.model.command.NyShuttleHttpCommand;
import com.zy.core.model.protocol.NyShuttleProtocol;

import java.util.*;

/**
@@ -52,8 +54,8 @@
        HashMap<String, Object> body = new HashMap<>();
        body.put("requestType", "move");//移动命令
        body.put("taskId", wrkNo);//任务号
        body.put("start", start);//起点
        body.put("target", target);//终点
        body.put("start", navigateNodeToPointNode(start));//起点
        body.put("target", navigateNodeToPointNode(target));//终点
        request.setBody(body);

        httpStandard.setRequest(request);
@@ -68,8 +70,8 @@
        HashMap<String, Object> body = new HashMap<>();
        body.put("requestType", in ? "intoLift" : "outLift");//进出提升机
        body.put("taskId", wrkNo);//任务号
        body.put("start", start);//起点
        body.put("target", target);//终点
        body.put("start", navigateNodeToPointNode(start));//起点
        body.put("target", navigateNodeToPointNode(target));//终点
        request.setBody(body);

        httpStandard.setRequest(request);
@@ -294,4 +296,13 @@
        return null;
    }

    //地图节点转换普通节点xyz
    public static NyShuttleProtocol.NyShuttlePointClass navigateNodeToPointNode(NavigateNode node) {
        NyShuttleProtocol.NyShuttlePointClass point = new NyShuttleProtocol.NyShuttlePointClass();
        point.setX(node.getX());
        point.setY(node.getY());
        point.setZ(node.getZ());
        return point;
    }

}

 src/main/java/com/zy/common/utils/NyShuttleOperaUtils.java

New file
@@ -0,0 +1,85 @@
package com.zy.common.utils;

import com.zy.asrs.utils.Utils;
import com.zy.common.model.NavigateNode;
import com.zy.common.model.NyShuttleOperaResult;
import com.zy.common.model.enums.NavigationMapType;
import com.zy.core.model.command.NyShuttleHttpCommand;
import java.util.ArrayList;
import java.util.List;

/**
 * 牛眼四向车操作工具类
 * 此工具类只要作用于获取小车的各类命令List，移动命令、搬运货物命令、复位命令等。如命令为移动命令，还将返回行走路径List
 */
public class NyShuttleOperaUtils {

    /**
     * 计算并获取小车从起点——中间点——目标点之间搬运货物动作命令
     * @param shuttleNo 小车号
     * @param wrkNo 工作号
     * @param startPoint 起点（小车当前位置）
     * @param middlePoint 中间点（货物位置）
     * @param targetPoint 目标点（货物目标位置）
     */
    public static NyShuttleOperaResult getShuttleTransportCommands(Integer shuttleNo, Integer wrkNo, String startPoint, String middlePoint, String targetPoint) {
        //计算起点到中间点命令
        NyShuttleOperaResult result1 = getStartToTargetCommands(shuttleNo, wrkNo, startPoint, middlePoint);
        //计算中间点到目标点命令
        NyShuttleOperaResult result2 = getStartToTargetCommands(shuttleNo, wrkNo, middlePoint, targetPoint);
        if (result1 == null || result2 == null) {
            //两个计算结果必须不为空，否则计算失败
            return null;
        }

        //行走路径
        ArrayList<NavigateNode> nodes = new ArrayList<>();
        nodes.addAll(result1.getNodes());
        nodes.addAll(result2.getNodes());

        //命令集合
        ArrayList<NyShuttleHttpCommand> commands = new ArrayList<>();
        commands.addAll(result1.getCommands());
        //当小车行走到中间点后，需要下发一条顶升命令将货物进行搬运
        commands.add(NyHttpUtils.getPalletLiftCommand(shuttleNo, wrkNo, true));
        commands.addAll(result2.getCommands());
        //当小车行走到目标点后，需要下发一条下降命令将货物放置
        commands.add(NyHttpUtils.getPalletLiftCommand(shuttleNo, wrkNo, false));
        return result(commands, nodes);
    }

    /**
     * 获取起点到目标点行走命令
     */
    public static NyShuttleOperaResult getStartToTargetCommands(Integer shuttleNo, Integer wrkNo, String startPoint, String targetPoint) {
        //计算起点到目标点行走节点
        List<NavigateNode> calc = NavigateUtils.calc(startPoint, targetPoint, NavigationMapType.NORMAL.id, Utils.getShuttlePoints(shuttleNo, Utils.getLev(startPoint)));
        if (calc == null) {
            return null;
        }

        //命令集合
        ArrayList<NyShuttleHttpCommand> commands = new ArrayList<>();

        //获取分段路径
        ArrayList<ArrayList<NavigateNode>> data = NavigateUtils.getSectionPath(calc);
        //将每一段路径分成command指令
        for (ArrayList<NavigateNode> nodes : data) {
            //开始路径
            NavigateNode startPath = nodes.get(0);
            //目标路径
            NavigateNode targetPath = nodes.get(nodes.size() - 1);
            //获取移动命令
            NyShuttleHttpCommand moveCommand = NyHttpUtils.getMoveCommand(shuttleNo, wrkNo, startPath, targetPath);
            commands.add(moveCommand);
        }

        return result(commands, calc);
    }

    //返回结果集
    public static NyShuttleOperaResult result(List<NyShuttleHttpCommand> commands, List<NavigateNode> nodes) {
        return new NyShuttleOperaResult(commands, nodes);
    }

}

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

@@ -7,10 +7,10 @@
    PAK_OUT(2, "出库"),
    PALLET_LIFT(3, "托盘顶升"),
    PALLET_DOWN(4, "托盘下降"),
    MOVE_LEFT(5, "左移"),
    MOVE_RIGHT(6, "右移"),
    MOVE_TOP(7, "前移"),
    MOVE_BOTTOM(8, "后移"),
    X_NEGATIVE(5, "X-方向"),
    X_POSITIVE(6, "X+方向"),
    Y_POSITIVE(7, "Y+方向"),
    Y_NEGATIVE(8, "Y-方向"),
    RESET(9, "状态复位"),
    SEARCH_LEFT(10, "正方向(右)寻库位"),
    SEARCH_RIGHT(11, "负方向(左)寻库位"),
@@ -20,6 +20,7 @@
    CHARGE(15, "充电"),
    MOVE_LIFT(16, "移动到提升机"),
    AVOID(17, "避让任务"),
    TRANSPORT(18, "搬运任务"),
    ;

    public Integer id;

 src/main/java/com/zy/core/model/command/NyShuttleHttpCommand.java

@@ -36,5 +36,10 @@

    }

    /**
     * 命令是否完成,默认false未完成
     */
    private Boolean complete = false;


}

 src/main/java/com/zy/core/model/command/ShuttleAssignCommand.java

@@ -46,7 +46,7 @@
    /**
     * 命令list
     */
    private List<ShuttleCommand> commands = new ArrayList<>();
    private List<NyShuttleHttpCommand> commands = new ArrayList<>();

    /**
     * 是否自动，true：自动模式，false：手动模式

 src/main/java/com/zy/core/model/command/ShuttleRedisCommand.java

@@ -3,7 +3,6 @@
import lombok.Data;

import java.io.Serializable;
import java.util.List;

/**
 * 四向穿梭车命令-存储在redis
@@ -22,9 +21,6 @@

    //命令
    private ShuttleAssignCommand assignCommand;

    //发生错误时尝试执行的指令，优先级最高
    private List<ShuttleCommand> errorCommands;

    //提升机安全锁定标记
    private Boolean liftSecurityMk = false;

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

@@ -5,7 +5,6 @@
import com.zy.asrs.service.BasShuttleService;
import com.zy.common.utils.NavigatePositionConvert;
import com.zy.core.News;
import com.zy.core.enums.ShuttleErrorCodeType;
import com.zy.core.enums.ShuttleProtocolStatusType;
import com.zy.core.enums.ShuttleStatusType;
import com.zy.core.model.command.ShuttleAssignCommand;
@@ -55,6 +54,11 @@
     * 目标库位
     */
    private String locNo;

    /**
     * 小车当前库位号
     */
    private String currentLocNo;

    /**
     * 作业标记
@@ -381,6 +385,12 @@
        return JSON.toJSONString(this.getCoord());
    }

    public void setPoint(NyShuttlePointClass point) {
        String locNo = NavigatePositionConvert.xyzToLocNo(point.getX(), point.getY(), point.getZ());
        this.point = point;
        this.currentLocNo = locNo;
    }

    // 是否处于空闲待命状态
    public Boolean isIdle() {
        boolean res = this.free == ShuttleStatusType.IDLE.id

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

@@ -1,5 +1,6 @@
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;
@@ -11,12 +12,15 @@
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.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.ShuttleRedisCommand;
import com.zy.core.model.protocol.LiftProtocol;
import com.zy.core.model.protocol.NyShuttleProtocol;
import lombok.Data;
import lombok.extern.slf4j.Slf4j;
@@ -24,6 +28,7 @@
import java.text.MessageFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

/**
 * 牛眼四向穿梭车线程
@@ -58,7 +63,7 @@
                        break;
                    // 写入数据
                    case 2:
                        write((ShuttleCommand) task.getData());
                        write((NyShuttleHttpCommand) task.getData());
                        break;
                    //下发任务
                    case 3:
@@ -82,7 +87,7 @@
                    && shuttleProtocol.getTaskNo() != 0
                    && shuttleProtocol.getPakMk()) {
                //执行下一步指令
                executeWork(shuttleProtocol.getTaskNo());
                executeWork(shuttleProtocol.getTaskNo().shortValue());
            }
        } catch (Exception e) {
            e.printStackTrace();
@@ -242,7 +247,7 @@

    }

    private boolean write(ShuttleCommand command){
    private boolean write(NyShuttleHttpCommand command){
        if (null == command) {
            News.error("四向穿梭车写入命令为空");
            return false;
@@ -258,558 +263,175 @@
            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 = NyHttpUtils.requestCommand(command);
        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("shuttle_wrk_no_" + assignCommand.getTaskNo(), JSON.toJSONString(redisCommand));
        //执行下发任务
        executeWork(assignCommand.getTaskNo());
    }

    //执行下发的指令
    private boolean executeWork(Integer wrkNo) {
//        //读取redis数据
//        if (wrkNo == null) {
//            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);
    private boolean executeWork(Short wrkNo) {
        //读取redis数据
        if (wrkNo == null) {
            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);
        List<NyShuttleHttpCommand> commands = redisCommand.getAssignCommand().getCommands();
        ShuttleAssignCommand assignCommand = redisCommand.getAssignCommand();
        //当前步序
        int commandStep = redisCommand.getCommandStep();
        if (commands.size() == 0) {
            return false;
        }
        //取出命令
        NyShuttleHttpCommand command = commands.get(commandStep);

        if (shuttleProtocol.getFree() == ShuttleStatusType.BUSY.id) {
            return false;//小车状态忙，禁止执行命令
        }

        //检测小车是否要进提升机，如需要进提升机则调度提升机
        if (!checkLiftStation(wrkNo)) {
            return false;
        }

        //检查路径是否可行走(检查路径锁定状态，检测路径是否有其他小车)


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

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

        //保存数据到数据库做流水
        BasShuttleOptService shuttleOptService = SpringUtils.getBean(BasShuttleOptService.class);
        if (shuttleOptService != null) {
            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),
                    null
            );
            shuttleOptService.insert(opt);
        }

        //判断数据是否执行完成
        if (commandStep < commands.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);
//                }
//            }
//            //任务数据保存到redis
//            redisUtil.set("shuttle_wrk_no_" + redisCommand.getWrkNo(), JSON.toJSONString(redisCommand));
//
//            if (!command.getComplete()) {
//                //上一条任务未完成，禁止下发命令
//                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);
//            }
//        }
//
//        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) {
//                    //提升机工作号和当前工作不相同，禁止下发命令
//                    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);
//                    }
//                }
//
//                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));
//                }
//
//            }
//
//        }

            //删除redis
            redisUtil.del("shuttle_wrk_no_" + redisCommand.getWrkNo());

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

        return true;
    }

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

        Object o = redisUtil.get("shuttle_wrk_no_" + wrkNo);
        if (o == null) {
            return false;
        }

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

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

        //检测是否存在提升机口的指令
        List<NyShuttleHttpCommand> commands = redisCommand.getAssignCommand().getCommands();
        if (commands.size() == 0) {
            return false;
        }

        if (!commands.get(commandStep).getMsgType().equals("move")) {
            return true;//不是行走命令，直接放行
        }


        return false;//默认不放行
    }

}

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

@@ -402,248 +402,247 @@

    //分配任务
    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;
//                }
//        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:
//            }

            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());
//            assignCommand.setCommands(commands);
//            assignCommand.setNodes(allNode);//当前任务所占用的节点list
//        }
//
//        redisCommand.setShuttleNo(assignCommand.getShuttleNo());//四向穿梭车号
//        redisCommand.setWrkNo(assignCommand.getTaskNo());//工作号
//        redisCommand.setCommandStep(0);//命令执行步序
//        redisCommand.setAssignCommand(assignCommand);//命令
//        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());
    }

    //执行下发的指令
@@ -653,261 +652,261 @@
            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);
                }
            }
            //任务数据保存到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) {
                    //提升机工作号和当前工作不相同，禁止下发命令
                    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);
                    }
                }

                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));
                }

            }

        }
//        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);
//                }
//            }
//            //任务数据保存到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) {
//                    //提升机工作号和当前工作不相同，禁止下发命令
//                    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);
//                    }
//                }
//
//                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));
//                }
//
//            }
//
//        }
        return true;
    }

@@ -920,154 +919,155 @@
            return false;
        }

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

        Object o = redisUtil.get("shuttle_wrk_no_" + wrkNo);
        if (o == null) {
            return false;
        }
        ShuttleRedisCommand redisCommand = JSON.parseObject(o.toString(), ShuttleRedisCommand.class);
        //当前步序
        int commandStep = redisCommand.getCommandStep();

        //检测是否存在提升机口的指令
        List<ShuttleCommand> commands = redisCommand.getAssignCommand().getCommands();
        if (commands.size() > 0) {
            if (commands.get(commandStep).getCommandWord() != 1) {
                //不是行走命令，直接放行
                return true;
            }

            if (commands.get(0).getStartCodeNum() == null) {
                return false;
            }
        }

        if (commands.size() == 0) {
            return false;
        }

        //当前等待执行的指令
        ShuttleCommand command = commands.get(commandStep);

        BasDevpService basDevpService = SpringUtils.getBean(BasDevpService.class);
        ArrayList<Short> qrCodeValues = new ArrayList<>();
        for (BasDevp basDevp : basDevpService.selectList(null)) {
            //将所有提升机口二维码存入list
            qrCodeValues.add(Short.parseShort(basDevp.getQrCodeValue()));
        }

        Integer siteNo = null;//站点号
        for (Short qrCodeValue : qrCodeValues) {
            //目标位置是提升机口，或起点位置是提升机口且目标是去提升机内
            if (command.getDistCodeNum() == null || command.getStartCodeNum() == null) {
                continue;
            }

            if (qrCodeValue.intValue() == command.getDistCodeNum().intValue() || (qrCodeValue.intValue() == command.getStartCodeNum().intValue() && command.getDistCodeNum().intValue() == liftProtocol.getBarcode().intValue())) {
                //存在
                BasDevp basDevp = basDevpService.queryByQrCode(qrCodeValue.intValue());
                siteNo = basDevp.getDevNo();
                break;
            }
        }

        if (siteNo == null) {
            //找不到站点，说明还未到提升机
            return true;
        }


//        //遍历所有指令，判断是否有到提升机口的指令或从提升机口前往提升机内的指令，并获取到达该提升机口所需步序
//        int step = 0;
//        Integer siteNo = null;//站点号
//        ShuttleCommand command = null;
//        for (int i = 0; i < commands.size(); i++) {
//            command = commands.get(i);
//            for (Short qrCodeValue : qrCodeValues) {
//                //目标位置是提升机口，或起点位置是提升机口且目标是去提升机内
//                if (command.getDistCodeNum() == null || command.getStartCodeNum() == null) {
//                    continue;
//                }
//        //拿到提升机线程
//        LiftThread liftThread = (LiftThread) SlaveConnection.get(SlaveType.Lift, 1);
//        if (liftThread == null) {
//            return false;
//        }
//        LiftProtocol liftProtocol = liftThread.getLiftProtocol();
//        if (liftProtocol == null) {
//            return false;
//        }
//
//                if (qrCodeValue.intValue() == command.getDistCodeNum().intValue() || (qrCodeValue.intValue() == command.getStartCodeNum().intValue() && command.getDistCodeNum().intValue() == liftProtocol.getBarcode().intValue())) {
//                    //存在
//                    step = i + 1;
//                    BasDevp basDevp = basDevpService.queryByQrCode(qrCodeValue.intValue());
//                    siteNo = basDevp.getDevNo();
//                    break;
//        Object o = redisUtil.get("shuttle_wrk_no_" + wrkNo);
//        if (o == null) {
//            return false;
//        }
//        ShuttleRedisCommand redisCommand = JSON.parseObject(o.toString(), ShuttleRedisCommand.class);
//        //当前步序
//        int commandStep = redisCommand.getCommandStep();
//
//        //检测是否存在提升机口的指令
//        List<ShuttleCommand> commands = redisCommand.getAssignCommand().getCommands();
//        if (commands.size() > 0) {
//            if (commands.get(commandStep).getCommandWord() != 1) {
//                //不是行走命令，直接放行
//                return true;
//            }
//
//            if (commands.get(0).getStartCodeNum() == null) {
//                return false;
//            }
//        }
//
//        if (commands.size() == 0) {
//            return false;
//        }
//
//        //当前等待执行的指令
//        ShuttleCommand command = commands.get(commandStep);
//
//        BasDevpService basDevpService = SpringUtils.getBean(BasDevpService.class);
//        ArrayList<Short> qrCodeValues = new ArrayList<>();
//        for (BasDevp basDevp : basDevpService.selectList(null)) {
//            //将所有提升机口二维码存入list
//            qrCodeValues.add(Short.parseShort(basDevp.getQrCodeValue()));
//        }
//
//        Integer siteNo = null;//站点号
//        for (Short qrCodeValue : qrCodeValues) {
//            //目标位置是提升机口，或起点位置是提升机口且目标是去提升机内
//            if (command.getDistCodeNum() == null || command.getStartCodeNum() == null) {
//                continue;
//            }
//
//            if (qrCodeValue.intValue() == command.getDistCodeNum().intValue() || (qrCodeValue.intValue() == command.getStartCodeNum().intValue() && command.getDistCodeNum().intValue() == liftProtocol.getBarcode().intValue())) {
//                //存在
//                BasDevp basDevp = basDevpService.queryByQrCode(qrCodeValue.intValue());
//                siteNo = basDevp.getDevNo();
//                break;
//            }
//        }
//
//        if (siteNo == null) {
//            //找不到站点，说明还未到提升机
//            return true;
//        }
//
//
////        //遍历所有指令，判断是否有到提升机口的指令或从提升机口前往提升机内的指令，并获取到达该提升机口所需步序
////        int step = 0;
////        Integer siteNo = null;//站点号
////        ShuttleCommand command = null;
////        for (int i = 0; i < commands.size(); i++) {
////            command = commands.get(i);
////            for (Short qrCodeValue : qrCodeValues) {
////                //目标位置是提升机口，或起点位置是提升机口且目标是去提升机内
////                if (command.getDistCodeNum() == null || command.getStartCodeNum() == null) {
////                    continue;
////                }
////
////                if (qrCodeValue.intValue() == command.getDistCodeNum().intValue() || (qrCodeValue.intValue() == command.getStartCodeNum().intValue() && command.getDistCodeNum().intValue() == liftProtocol.getBarcode().intValue())) {
////                    //存在
////                    step = i + 1;
////                    BasDevp basDevp = basDevpService.queryByQrCode(qrCodeValue.intValue());
////                    siteNo = basDevp.getDevNo();
////                    break;
////                }
////            }
////        }
////
////        if (step == 0) {
////            //无需后续检测，直接放行
////            return true;
////        }
//
//        //判断下一步是否为提升机口或提升机内
//        if (commandStep < commands.size()) {
//            ShuttleCommand command1 = commands.get(commandStep);
//            Short distCodeNum = command1.getDistCodeNum();
//            if (distCodeNum != null) {
//                BasDevp basDevp = basDevpService.queryByQrCode(Integer.valueOf(distCodeNum));
//                if (basDevp == null && distCodeNum.intValue() != liftProtocol.getBarcode().intValue()) {
//                    return true;//下一步不是提升机口，跳过后续流程
//                }
//            }
//        }
//
//        if (step == 0) {
//            //无需后续检测，直接放行
//        //获取四向穿梭车当前楼层
//        String shuttleLocNo = shuttleProtocol.getCurrentLocNo();//二维码对应库位号
//        Integer shuttleLocNoLev = shuttleLocNo == null ? 0 : Utils.getLev(shuttleLocNo);//库位号对应层高
//
//        //判断穿梭车和提升机是否在目标楼层
//        if (shuttleLocNoLev >= 2) {
//            shuttleLocNoLev++;
//        }
//
//        //判断输送线站点是否给出提升机到位信号
//        SiemensDevpThread siemensDevpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, 1);
//        StaProtocol staProtocol = siemensDevpThread.getStation().get(siteNo);
//        if (!staProtocol.isLiftArrival()) {
//            //输送线反馈提升机没有到位
//            executeLift(liftThread, liftProtocol, redisCommand, shuttleLocNoLev);//调度提升机
//            return false;
//        }
//
//        if (shuttleProtocol.getCurrentCode().intValue() == liftProtocol.getBarcode().intValue()) {
//            //小车处于提升机内
//            return true;
//        }else {
//            if (liftProtocol.getPositionArrivalFeedback$() == shuttleLocNoLev) {
//                //判断提升机是否有任务号
//                if (liftProtocol.getTaskNo().intValue() != 0) {
//                    //判断任务号是否和当前小车任务一致
//                    if (liftProtocol.getTaskNo().intValue() != wrkNo.intValue()) {
//                        return false;//任务号不一致，且提升机任务号不为0
//                    }
//                }
//                liftProtocol.setTaskNo(wrkNo);//给提升机写工作号，防止被占用
//                WrkMastService wrkMastService = SpringUtils.getBean(WrkMastService.class);
//                WrkMast wrkMast = wrkMastService.selectById(shuttleProtocol.getTaskNo());
//                if (wrkMast != null) {
//                    wrkMast.setLiftNo(liftProtocol.getLiftNo().intValue());//锁定提升机，防止被抢占
//                    wrkMastService.updateById(wrkMast);
//                }
//                return true;//提升机到位
//            }
//            executeLift(liftThread, liftProtocol, redisCommand, shuttleLocNoLev);//调度提升机
//            return false;//提升机没有到位
//        }

        //判断下一步是否为提升机口或提升机内
        if (commandStep < commands.size()) {
            ShuttleCommand command1 = commands.get(commandStep);
            Short distCodeNum = command1.getDistCodeNum();
            if (distCodeNum != null) {
                BasDevp basDevp = basDevpService.queryByQrCode(Integer.valueOf(distCodeNum));
                if (basDevp == null && distCodeNum.intValue() != liftProtocol.getBarcode().intValue()) {
                    return true;//下一步不是提升机口，跳过后续流程
                }
            }
        }

        //获取四向穿梭车当前楼层
        String shuttleLocNo = shuttleProtocol.getCurrentLocNo();//二维码对应库位号
        Integer shuttleLocNoLev = shuttleLocNo == null ? 0 : Utils.getLev(shuttleLocNo);//库位号对应层高

        //判断穿梭车和提升机是否在目标楼层
        if (shuttleLocNoLev >= 2) {
            shuttleLocNoLev++;
        }

        //判断输送线站点是否给出提升机到位信号
        SiemensDevpThread siemensDevpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, 1);
        StaProtocol staProtocol = siemensDevpThread.getStation().get(siteNo);
        if (!staProtocol.isLiftArrival()) {
            //输送线反馈提升机没有到位
            executeLift(liftThread, liftProtocol, redisCommand, shuttleLocNoLev);//调度提升机
            return false;
        }

        if (shuttleProtocol.getCurrentCode().intValue() == liftProtocol.getBarcode().intValue()) {
            //小车处于提升机内
            return true;
        }else {
            if (liftProtocol.getPositionArrivalFeedback$() == shuttleLocNoLev) {
                //判断提升机是否有任务号
                if (liftProtocol.getTaskNo().intValue() != 0) {
                    //判断任务号是否和当前小车任务一致
                    if (liftProtocol.getTaskNo().intValue() != wrkNo.intValue()) {
                        return false;//任务号不一致，且提升机任务号不为0
                    }
                }
                liftProtocol.setTaskNo(wrkNo);//给提升机写工作号，防止被占用
                WrkMastService wrkMastService = SpringUtils.getBean(WrkMastService.class);
                WrkMast wrkMast = wrkMastService.selectById(shuttleProtocol.getTaskNo());
                if (wrkMast != null) {
                    wrkMast.setLiftNo(liftProtocol.getLiftNo().intValue());//锁定提升机，防止被抢占
                    wrkMastService.updateById(wrkMast);
                }
                return true;//提升机到位
            }
            executeLift(liftThread, liftProtocol, redisCommand, shuttleLocNoLev);//调度提升机
            return false;//提升机没有到位
        }

        return false;
    }

    private boolean executeLift(LiftThread liftThread, LiftProtocol liftProtocol, ShuttleRedisCommand redisCommand, Integer shuttleLocNoLev) {//调度提升机
@@ -1113,72 +1113,6 @@
        liftAssignCommand.setTaskNo(liftProtocol.getTaskNo());
        //下发任务
        MessageQueue.offer(SlaveType.Lift, liftProtocol.getLiftNo().intValue(), new Task(3, liftAssignCommand));
        return true;
    }

    /**
     * 复位并尝试修复错误
     */
    private boolean resetAndTryFix(Short wrkNo) {
        //读取redis数据
        if (wrkNo == null) {
            return false;
        }

        Object o = redisUtil.get("shuttle_wrk_no_" + wrkNo);
        if (o == null) {
            return false;
        }

        ShuttleRedisCommand redisCommand = JSON.parseObject(o.toString(), ShuttleRedisCommand.class);
        List<ShuttleCommand> commands = redisCommand.getAssignCommand().getCommands();
        //当前步序
        int commandStep = redisCommand.getCommandStep();
        //path路径数目
        int size = commands.size();

        ArrayList<ShuttleCommand> list = new ArrayList<>();

        //取出命令
        ShuttleCommand command = commands.get(commandStep - 1);

        //复位命令
        ShuttleCommand resetCommand = getResetCommand();
        list.add(resetCommand);

        //车辆空闲，等待写入找库位命令
        //找库位命令
        short direction = 1;
        switch (command.getRunDirection()) {//转换运行方向
            case 1:
                direction = 2;
                break;
            case 2:
                direction = 1;
                break;
            case 3:
                direction = 4;
                break;
            case 4:
                direction = 3;
                break;
            default:
                direction = 1;
        }
        //找库位命令
        ShuttleCommand searchCommand = getFindLocCommand(direction, 1200, (short) 1000);
        list.add(searchCommand);

        //移动车辆，需要在执行完寻找定位点后再执行
        ShuttleCommand moveCommand = new ShuttleCommand();
        moveCommand.setCommandWord((short) 1);
        moveCommand.setStartCodeNum(command.getStartCodeNum());//存入目标库位号
        list.add(moveCommand);

        redisCommand.setErrorCommands(list);
        //任务数据保存到redis
        redisUtil.set("shuttle_wrk_no_" + wrkNo, JSON.toJSONString(redisCommand));
        shuttleProtocol.setProtocolStatus(ShuttleProtocolStatusType.FIXING);
        return true;
    }


 src/main/webapp/static/readStatus.json

@@ -25,8 +25,8 @@
            "surplusQuantity": 450,
            "countQuantity": 500,
            "point": {
                "x": 1,
                "y": 2,
                "x": 4,
                "y": 21,
                "z": 1
            },
            "coord": {

 src/main/webapp/views/shuttle.html

@@ -70,6 +70,7 @@
                            <th>总电量</th>
                            <th>总里程数</th>
                            <th>作业标记</th>
                            <th>当前库位</th>
                        </tr>
                    </thead>
                    <tbody>
@@ -114,8 +115,7 @@
                                        </div>

                                        <div style="margin-top: 10px;">
                                            <button class="item" onclick="shuttleOperator(1)">入库</button>
                                            <button class="item" onclick="shuttleOperator(2)">出库</button>
                                            <button class="item" onclick="shuttleOperator(18)">搬运货物</button>
                                            <button class="item" onclick="shuttleOperator(14)">移动到目标库位</button>
                                            <button class="item" onclick="shuttleOperator(16)">移动到提升机</button>
                                        </div>
@@ -130,50 +130,42 @@
                                        <div class="button-group">
                                            <button class="item" onclick="shuttleOperator(3)">托盘顶升</button>
                                            <button class="item" onclick="shuttleOperator(4)">托盘下降</button>
                                            <button class="item" onclick="shuttleOperator(5)">左移</button>
                                            <button class="item" onclick="shuttleOperator(6)">右移</button>
                                            <button class="item" onclick="shuttleOperator(7)">后移</button>
                                            <button class="item" onclick="shuttleOperator(8)">前移</button>
                                            <button class="item" onclick="shuttleOperator(9)">复位</button>
                                            <button class="item" onclick="shuttleOperator(10)">正方向(右)寻库位</button>
                                            <button class="item" onclick="shuttleOperator(11)">负方向(左)寻库位</button>
                                            <button class="item" onclick="shuttleOperator(12)">正方向(前)寻库位</button>
                                            <button class="item" onclick="shuttleOperator(13)">负方向(后)寻库位</button>
                                            <button class="item" onclick="shuttleOperator(15)">充电开关</button>
                                            <button class="item" onclick="shuttleOperator(9)">复位</button>
                                        </div>
                                    </div>
                                </div>
                            </div>

                            <div style="width: 20%;">
                                <div class="operator-item" style="height: auto;width: 100%;">
                                    <span class="select-title">设置配置参数</span>
                                    <div class="select-container" style="height: auto;padding: 30px 10px 10px 10px;">
                                        <div class="select-container-item">
                                            <span>运行速度</span>
                                            <label><input id="runSpeed" type="text" name="runSpeed" /></label>
                                        </div>
                                        <div class="select-container-item">
                                            <span>充电阈值</span>
                                            <label><input id="chargeLine" type="text" name="runSpeed" /></label>
                                        </div>
<!--                            <div style="width: 20%;">-->
<!--                                <div class="operator-item" style="height: auto;width: 100%;">-->
<!--                                    <span class="select-title">设置配置参数</span>-->
<!--                                    <div class="select-container" style="height: auto;padding: 30px 10px 10px 10px;">-->
<!--                                        <div class="select-container-item">-->
<!--                                            <span>运行速度</span>-->
<!--                                            <label><input id="runSpeed" type="text" name="runSpeed" /></label>-->
<!--                                        </div>-->
<!--                                        <div class="select-container-item">-->
<!--                                            <span>充电阈值</span>-->
<!--                                            <label><input id="chargeLine" type="text" name="runSpeed" /></label>-->
<!--                                        </div>-->

                                        <div>
                                            <button class="item" onclick="shuttleParamSave()">保存</button>
                                        </div>
                                    </div>
                                </div>
                            </div>
<!--                                        <div>-->
<!--                                            <button class="item" onclick="shuttleParamSave()">保存</button>-->
<!--                                        </div>-->
<!--                                    </div>-->
<!--                                </div>-->
<!--                            </div>-->

                            <div style="width: 15%;">
                                <div class="operator-item" style="height: auto;width: 100%;">
                                    <span class="select-title">配置参数</span>
                                    <div class="select-container" style="height: auto;padding: 30px 10px 10px 10px;">
                                        <div>运行速度：<span id="runSpeedText"></span></div>
                                        <div>充电阈值：<span id="chargeLineText"></span></div>
                                    </div>
                                </div>
                            </div>
<!--                            <div style="width: 15%;">-->
<!--                                <div class="operator-item" style="height: auto;width: 100%;">-->
<!--                                    <span class="select-title">配置参数</span>-->
<!--                                    <div class="select-container" style="height: auto;padding: 30px 10px 10px 10px;">-->
<!--                                        <div>运行速度：<span id="runSpeedText"></span></div>-->
<!--                                        <div>充电阈值：<span id="chargeLineText"></span></div>-->
<!--                                    </div>-->
<!--                                </div>-->
<!--                            </div>-->
                        </div>
                    </fieldset>
                </div>
@@ -378,6 +370,7 @@
                        setVal(tr.children("td").eq(9), table[i-1].countQuantity);
                        setVal(tr.children("td").eq(10), table[i-1].statusSum.mileage);
                        setVal(tr.children("td").eq(11), table[i-1].pakMk$);
                        setVal(tr.children("td").eq(12), table[i-1].currentLocNo);
                        if (table[i-1].shuttleNo == parseInt($('input[name="shuttleSelect"]:checked').val())) {
                            $("#runSpeedText").text(table[i-1].runSpeed)
                            $("#chargeLineText").text(table[i-1].chargeLine + "%")