#改造

cpT

2025-06-22 87b052cbd5bb44bf90ac4e9c4aeaf1cdcf5acf63

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

@@ -17,8 +17,8 @@
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.SlaveType;
import com.zy.core.enums.SteLocaType;
import com.zy.core.enums.SteStatusType;
import com.zy.core.model.SteSlave;
import com.zy.core.model.Task;
@@ -43,9 +43,8 @@
    private SteSlave slave;
    private SteProtocol steProtocol;
    private short heartBeatVal = 1;
    private boolean V20011 = true;
    private boolean V20001 = true;
    private boolean resetFlag = false;
    private boolean connectSte = false;

    public SteThread(SteSlave slave) {
        this.slave = slave;
@@ -53,10 +52,40 @@

    @Override
    @SuppressWarnings("InfiniteLoopStatement")
    public void run() {
        this.connect();
    public void run() {        connectSte = this.connect();
        while(!connectSte){
            try {
                connectSte = this.connect();
                Thread.sleep(100);
            } catch (Exception e){

            }
        }

        // 启动线程自动重连
        new Thread(this::steConnect).start();

        // 启动读数据线程
        new Thread(this::readStatusSte).start();

        // 启动任务下发线程
        new Thread(this::taskIssued).start();
    }

    /**
     * 任务下发
     */
    private void taskIssued() {
        while (true) {
            try {
                if(!connectSte){
                    try {
                        Thread.sleep(1000L);
                    } catch (Exception e){

                    }
                    continue;
                }
                int step = 1;
                Task task = MessageQueue.poll(SlaveType.Ste, slave.getId());
                if (task != null) {
@@ -65,7 +94,7 @@
                switch (step) {
                    // 读数据
                    case 1:
                        readStatus();
//                        readStatus();
                        break;
                    // 写入数据
                    case 2:
@@ -76,12 +105,62 @@
                }
                // 心跳
//                heartbeat();
                Thread.sleep(500);
                Thread.sleep(50);
            } catch (Exception e) {
                e.printStackTrace();
                log.error("STE写线程异常"+e.getMessage());

//                e.printStackTrace();
            }

        }
    }

    private void steConnect() {
        while (true) {
            try {
                Thread.sleep(1000);
                if(!connectSte){
                    try {
                        connectSte = this.connect();
                        Thread.sleep(100);
                    } catch (Exception e){

                    }
                }
            } catch (Exception e) {
                log.error("ste连接失败！！！ ===>> [id:{}] [ip:{}] [port:{}]", slave.getId(), slave.getIp(), slave.getPort());
                initSte();
//                e.printStackTrace();
            }
        }
    }

    private void readStatusSte() {
        while (true) {
            try {
                if(!connectSte){
                    try {
                        Thread.sleep(1000L);
                    } catch (Exception e){

                    }
                    initSte();
                    continue;
                }
                Thread.sleep(50);
//                System.out.println("读线程"+ slave.getId());

                readStatus();

            } catch (Exception e) {
                log.error("ste数据读取线程异常！！！ ===>> [id:{}] [ip:{}] [port:{}]", slave.getId(), slave.getIp(), slave.getPort());

                initSte();
//                e.printStackTrace();
            }

        }

    }

    /**
@@ -102,10 +181,10 @@
    @Override
    public boolean connect() {
        boolean result = false;
        // 不能有 槽号 和 机架号
        siemensS7Net = new SiemensS7Net(SiemensPLCS.S200Smart, slave.getIp());
//        siemensS7Net.setRack(slave.getRack().byteValue());
//        siemensS7Net.setSlot(slave.getSlot().byteValue());
        //
        siemensS7Net = new SiemensS7Net(SiemensPLCS.S1200, slave.getIp());
        siemensS7Net.setRack(slave.getRack().byteValue());
        siemensS7Net.setSlot(slave.getSlot().byteValue());
        OperateResult connect = siemensS7Net.ConnectServer();
        if(connect.IsSuccess){
            result = true;
@@ -125,106 +204,56 @@
     */
    private void readStatus(){
        try {
            OperateResultExOne<byte[]> result = siemensS7Net.Read("V800", (short) 70);
            OperateResultExOne<byte[]> result = siemensS7Net.Read("DB101.0", (short) 28);
            if (result.IsSuccess) {
                if (null == steProtocol) {
                    steProtocol = new SteProtocol();
                    steProtocol.setSteNo(slave.getId().shortValue());
                }
//                steProtocol.setSteNo(siemensS7Net.getByteTransform().TransInt16(result.Content, 0));
                steProtocol.setMode(siemensS7Net.getByteTransform().TransInt16(result.Content, 2));
                steProtocol.setStatus(siemensS7Net.getByteTransform().TransInt16(result.Content, 4));
                OperateResultExOne<Boolean> executeRes = siemensS7Net.ReadBool("V2001.0");
                if (executeRes.IsSuccess) {
                    steProtocol.setExecute(executeRes.Content);
                }
                OperateResultExOne<Boolean> waitingRes = siemensS7Net.ReadBool("V2001.1");

                OperateResultExOne<Boolean> waitingRes = siemensS7Net.ReadBool("DB101.20.2");
                if (waitingRes.IsSuccess) {
                    steProtocol.setWaiting(waitingRes.Content);
                }
//                if (steProtocol.getSteNo()==1){
//                    if (!steProtocol.getWaiting().equals(V20011)){
//                        News.error("小车号 ={} :V2001.1地址读取值不一致，读={}  记录={}",steProtocol.getSteNo(),steProtocol.getWaiting(),V20011);
//                    }
//                    V20011=steProtocol.getWaiting();
//                    OperateResultExOne<Boolean> waitingRes2 = siemensS7Net.ReadBool("V2000.1");
//                    if (waitingRes2.IsSuccess) {
//                        if (!waitingRes2.Content.equals(V20001)){
//                            News.error("小车号 ={} :V2000.1地址读取值不一致，读={} 记录={}",steProtocol.getSteNo(),waitingRes2.Content,V20001);
//                        }
//                        V20001=waitingRes2.Content;
//                    }
//                    OperateResultExOne<Boolean> waitingRes3 = siemensS7Net.ReadBool("V2500.1");
//                    if (waitingRes3.IsSuccess) {
//                        if (!waitingRes3.Content.equals(waitingRes2.Content)){
//                            News.error("小车号 ={} :V2000.1地址读取值不一致，读={} ， V2500.1地址读取值不一致，读={}",steProtocol.getSteNo(),waitingRes2.Content,waitingRes3.Content);

                steProtocol.setCharge(siemensS7Net.getByteTransform().TransSingle(result.Content, 6));
                steProtocol.setTaskNo(siemensS7Net.getByteTransform().TransInt16(result.Content, 10));
                steProtocol.setTaskType(siemensS7Net.getByteTransform().TransInt16(result.Content, 12));
                steProtocol.setRow(siemensS7Net.getByteTransform().TransInt16(result.Content, 14));
                steProtocol.setBay(siemensS7Net.getByteTransform().TransInt16(result.Content, 16));
                steProtocol.setLev(siemensS7Net.getByteTransform().TransInt16(result.Content, 18));
                steProtocol.setLoca(siemensS7Net.getByteTransform().TransInt16(result.Content, 20));
                steProtocol.setLocaStart(siemensS7Net.getByteTransform().TransInt16(result.Content, 22));
                steProtocol.setLocaEnd(siemensS7Net.getByteTransform().TransInt16(result.Content, 24));
                boolean[] status = siemensS7Net.getByteTransform().TransBool(result.Content, 26, 1);
//                steProtocol.setReady(status[0]?(short)1:(short)0);
//                steProtocol.setReady(status[1]?(short)1:(short)0);
                steProtocol.setReady(status[3]?(short)1:(short)0);
//                steProtocol.setReady(status[3]?(short)1:(short)0);
//                steProtocol.setTrack(status[6]?(short)1:(short)0);

                boolean[] status2 = siemensS7Net.getByteTransform().TransBool(result.Content, 27, 1);

                steProtocol.setChargeStatus(status2[0]?(short)1:(short)0);
                steProtocol.setTrack(status2[1]?(short)1:(short)0);

//                steProtocol.setLoad(status2[6]?(short)1:(short)0);
                steProtocol.setLoad(status2[7]?(short)1:(short)0);

                OutputQueue.STE.offer(MessageFormat.format("【{0}】[id:{1}] <<<<< 实时数据更新成功",DateUtils.convert(new Date()), slave.getId()));

//                // 复位信号
//                if (steProtocol.getWaiting()) {
//                    if (resetFlag) {
//                        SteCommand steCommand = new SteCommand();
//                        steCommand.setComplete(true);
//                        if (write(steCommand) && confirmPos()) {
//                            resetFlag = false;
//                        }
//                    }
//                }
                OperateResultExOne<Boolean> inEmptyRes = siemensS7Net.ReadBool("V2001.2");
                if (inEmptyRes.IsSuccess) {
                    steProtocol.setInEmpty(inEmptyRes.Content);
                }
                OperateResultExOne<Boolean> outEmptyRes = siemensS7Net.ReadBool("V2001.3");
                if (outEmptyRes.IsSuccess) {
                    steProtocol.setOutEmpty(outEmptyRes.Content);
                }
                steProtocol.setAlarm(siemensS7Net.getByteTransform().TransInt16(result.Content, 6));
                steProtocol.setAlarm0(siemensS7Net.getByteTransform().TransInt16(result.Content, 8));
                steProtocol.setCharge(siemensS7Net.getByteTransform().TransSingle(result.Content, 10));
//                steProtocol.setFullCharge();
//                steProtocol.setLowCharge();
                steProtocol.setFeed(siemensS7Net.getByteTransform().TransInt16(result.Content, 14));
                steProtocol.setLoca(siemensS7Net.getByteTransform().TransInt16(result.Content, 16));
//                steProtocol.setCloser();
//                steProtocol.setSpeed();
                steProtocol.setPos(siemensS7Net.getByteTransform().TransInt16(result.Content, 18));
                steProtocol.setLoad(siemensS7Net.getByteTransform().TransInt16(result.Content, 20));
                steProtocol.setTrack(siemensS7Net.getByteTransform().TransInt16(result.Content, 22));
                steProtocol.setTaskNo(siemensS7Net.getByteTransform().TransInt16(result.Content, 24));
                steProtocol.setTaskType(siemensS7Net.getByteTransform().TransInt16(result.Content, 28));
                steProtocol.setRow(siemensS7Net.getByteTransform().TransInt16(result.Content, 30));
                steProtocol.setBay(siemensS7Net.getByteTransform().TransInt16(result.Content, 32));
                steProtocol.setLev(siemensS7Net.getByteTransform().TransInt16(result.Content, 34));

//                steProtocol.setHisTaskNo(siemensS7Net.getByteTransform().TransInt32(result.Content, 58));
//                steProtocol.setHisTaskStatus(siemensS7Net.getByteTransform().TransInt16(result.Content, 62));
//                steProtocol.setCheckQty(siemensS7Net.getByteTransform().TransInt16(result.Content, 64));
                steProtocol.setReady(siemensS7Net.getByteTransform().TransInt16(result.Content, 36));
//                steProtocol.setChargeNo(siemensS7Net.getByteTransform().TransInt16(result.Content, 68));

//                steProtocol.setHeart(siemensS7Net.getByteTransform().TransInt16(result.Content, 72));
                steProtocol.setCrnStopRun(siemensS7Net.getByteTransform().TransInt16(result.Content, 38));
                steProtocol.setCrnStopFork(siemensS7Net.getByteTransform().TransInt16(result.Content, 40));
                steProtocol.setCrnAllowRun(siemensS7Net.getByteTransform().TransInt16(result.Content, 42));
                steProtocol.setChargeStatus(siemensS7Net.getByteTransform().TransInt16(result.Content, 44));
                OperateResultExOne<Boolean> steChargeRes = siemensS7Net.ReadBool("V740.6");
                if (steChargeRes.IsSuccess) {
                    steProtocol.setSteCharge(steChargeRes.Content);
                    if (steChargeRes.Content){
                        steProtocol.setChargeStatus((short)1);
                    }
                }

                OutputQueue.STE.offer(MessageFormat.format("【{0}】[id:{1}] <<<<< 实时数据更新成功", DateUtils.convert(new Date()), slave.getId()));

                // 复位信号
                if (steProtocol.getWaiting()) {
                    News.info("-------------第一步、[穿梭车号：{}, 工作号：{}]==>> 状态为{}，等待WCS确认！！{}",
                            slave.getId(),steProtocol.getTaskNo(),steProtocol.getStatus(), resetFlag);
                    if (resetFlag) {
                        News.info("第二步、收到主线程复位标记 resetFlag = true,[穿梭车号：{}, 工作号：{}]==>> 状态为{}，等待WCS确认！！{}",
                                slave.getId(),steProtocol.getTaskNo(),steProtocol.getStatus(), resetFlag);
                        SteCommand steCommand = new SteCommand();
                        steCommand.setComplete(true);
                        if (write(steCommand) && confirmPos()) {
                            resetFlag = false;
                            News.info("第三步、发送复位命令成功 resetFlag = false,[穿梭车号：{}, 工作号：{}]==>> 状态为{}，等待WCS确认！！{}",
                                    slave.getId(),steProtocol.getTaskNo(),steProtocol.getStatus(), resetFlag);
                        }
                    }
                }


                // 根据实时信息更新数据库
                BasSteService service = SpringUtils.getBean(BasSteService.class);
@@ -243,13 +272,11 @@

                }
            } else {
                OutputQueue.STE.offer(MessageFormat.format("【{0}】{1}穿梭车plc状态信息失败", DateUtils.convert(new Date()), slave.getId()));
                OutputQueue.STE.offer(MessageFormat.format("【{0}】{1}穿梭车plc状态信息失败",DateUtils.convert(new Date()), slave.getId()));
                throw new CoolException(MessageFormat.format( "穿梭车plc状态信息失败 ===>> [id:{0}] [ip:{1}] [port:{2}]", slave.getId(), slave.getIp(), slave.getPort()));
            }
        } catch (Exception e) {
//            e.printStackTrace();
            OutputQueue.STE.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());
            initSte();
        }

@@ -258,64 +285,34 @@
    /**
     * 写入数据
     */
    private boolean write(SteCommand command) throws InterruptedException {
        if (null == command) {
    private boolean write(SteCommand command){
        return this.write(command, 1);
    }

    /**
     * 写入数据
     */
    private boolean write(SteCommand command, int times){
        if (null == command || times > 2) {
            News.error("穿梭车写入命令为空");
            return false;
        }
        //判断小车是否在充电
        SiemensDevpThread devpThread = (SiemensDevpThread) SlaveConnection.get(SlaveType.Devp, 1);
        if (devpThread.charge0
                && !Cools.isEmpty(command.getRow(),command.getBay(),command.getLev())
                && command.getRow().intValue()==1 && command.getBay().intValue()==1 && command.getLev().intValue()==1){
            // led 异常显示
            LedThread ledThread1 = (LedThread) SlaveConnection.get(SlaveType.Led, 1);
            LedThread ledThread2 = (LedThread) SlaveConnection.get(SlaveType.Led, 2);
            LedThread ledThread3 = (LedThread) SlaveConnection.get(SlaveType.Led, 3);
            if (ledThread1 != null && ledThread2 != null && ledThread3 != null) {
                MessageQueue.offer(SlaveType.Led, 1, new Task(3, "穿梭车正在1排充电桩充电"));
                MessageQueue.offer(SlaveType.Led, 2, new Task(3, "穿梭车正在1排充电桩充电"));
                MessageQueue.offer(SlaveType.Led, 3, new Task(3, "穿梭车正在1排充电桩充电"));
            }
            News.error("穿梭车正在1排充电桩充电");
            return false;
        }else if (devpThread.charge1
                && !Cools.isEmpty(command.getRow(),command.getBay(),command.getLev())
                && command.getRow().intValue()==13 && command.getBay().intValue()==1 && command.getLev().intValue()==1){
            // led 异常显示
            LedThread ledThread1 = (LedThread) SlaveConnection.get(SlaveType.Led, 1);
            LedThread ledThread2 = (LedThread) SlaveConnection.get(SlaveType.Led, 2);
            LedThread ledThread3 = (LedThread) SlaveConnection.get(SlaveType.Led, 3);
            if (ledThread1 != null && ledThread2 != null && ledThread3 != null) {
                MessageQueue.offer(SlaveType.Led, 1, new Task(3, "穿梭车正在13排充电桩充电"));
                MessageQueue.offer(SlaveType.Led, 2, new Task(3, "穿梭车正在13排充电桩充电"));
                MessageQueue.offer(SlaveType.Led, 3, new Task(3, "穿梭车正在13排充电桩充电"));
            }
            News.error("穿梭车正在13排充电桩充电");
            return false;
        }
        command.setSteNo(slave.getId());
        OperateResult result = null;
        News.error("穿梭车写入命令"+JSON.toJSONString(command));

        // 开始任务
        if (!command.getComplete()) {
            //组织任务前，先清空写任务确认位，以及任务完成确认位
            siemensS7Net.Write("V2000.0", false);
            siemensS7Net.Write("V2000.1", false);
//            siemensS7Net.Write("V2500.1", false);
            Thread.sleep(200);
            OperateResultExOne<Boolean> waitingRes2 = siemensS7Net.ReadBool("V2000.1");
            if (waitingRes2.IsSuccess) {
                if(!waitingRes2.Content){
                    News.error("重置任务完成确认位成功");
                } else {
                    News.error("重置任务完成确认位失败1");
                }
            } else {
                News.error("重置任务完成确认位失败2");
            }

            siemensS7Net.Write("DB100.0", (short) 0);//设备号
            siemensS7Net.Write("DB100.2", (short) 0);//任务号
            siemensS7Net.Write("DB100.12", (short) 0);//起始点位
            siemensS7Net.Write("DB100.14", (short) 0);//目的点位
            siemensS7Net.Write("DB100.16.0", false);//任务开始确认位
            siemensS7Net.Write("DB100.16.1", false);//任务完成确认位
//            siemensS7Net.Write("DB100.18", (short) 0);//硫化罐号
            // 1.任务号
            OperateResult result0 = siemensS7Net.Write("V998", command.getTaskNo().shortValue());
            OperateResult result0 = siemensS7Net.Write("DB100.2", command.getTaskNo().shortValue());
            try {
                Thread.sleep(200);
            } catch (InterruptedException e) {
@@ -324,41 +321,28 @@
            // 作业
            if (command.getTaskMode() != 0) {
                // 2.作业
                OperateResult result1 = siemensS7Net.Write("V1000", command.getTaskMode());
                OperateResult result1 = siemensS7Net.Write("DB100.4", command.getTaskMode());
                OperateResult result2 = siemensS7Net.Write("DB100.12", (short) command.getStartLoad().shortValue());//起始点位
                OperateResult result3 = siemensS7Net.Write("DB100.14", (short) command.getEndLoad().shortValue());//目的点位
                OperateResult result4 = siemensS7Net.Write("DB100.18", (short) command.getJarNo());//目的点位
                // 3.确认开始任务
                if (result0.IsSuccess && result1.IsSuccess) {
                    result = siemensS7Net.Write("V2000.0", true);
                    siemensS7Net.Write("V2000.1", false);
//                    siemensS7Net.Write("V2500.1", false);
                }
                if (result0.IsSuccess && result1.IsSuccess && result2.IsSuccess && result3.IsSuccess && result4.IsSuccess) {
                    result = siemensS7Net.Write("DB100.16.0", true);

            // 其他指令
            } else {
                // 控制模式
                if (command.getControlMode() != null) {
                    result =  siemensS7Net.Write("V1010", command.getControlMode());
                // 复位信号
                } else if (command.getReset() != null) {
                    result =  siemensS7Net.Write("V2000.2", command.getReset());
                // 删除指令
                } else if (command.getDelete() != null) {
                    result =  siemensS7Net.Write("V2000.3", command.getDelete());
                // 无效指令
                } else if (command.getRun() != null) {
                    result =  siemensS7Net.Write("V1016", command.getRun());
                    // 无效指令
                }else {
                    return false;
                    try {
                        Thread.sleep(300);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }

        // 任务完成
            // 任务完成
        } else {
            siemensS7Net.Write("V2000.0", false);
            siemensS7Net.Write("V998", (short) 0);
            siemensS7Net.Write("V1000", (short) 0);
            result = siemensS7Net.Write("V2000.1", true);
//            result = siemensS7Net.Write("V2500.1", true);
//            siemensS7Net.Write("DB100.2", (short) 0);//任务号
//            siemensS7Net.Write("DB100.4.0", (short) 0);//任务类型
            siemensS7Net.Write("DB100.16.0", false);//任务开始确认位

            result = siemensS7Net.Write("DB100.16.1", true);//任务完成确认
        }

        try {
@@ -391,13 +375,6 @@
        } catch (Exception ignore) {}

        if (result != null && result.IsSuccess) {
            // 维护数据库排列层
            if (!steProtocol.getWaiting()) {
                if (!Cools.isEmpty(command.getRow(), command.getBay(), command.getLev())) {
                    this.modifyPos(command.getRow().intValue(), command.getBay().intValue(), command.getLev().intValue());
                }
            }

            News.info("穿梭车命令下发[id:{}] >>>>> {}", slave.getId(), JSON.toJSON(command));
            OutputQueue.STE.offer(MessageFormat.format("【{0}】[id:{1}] >>>>> 命令下发： {2}", DateUtils.convert(new Date()), slave.getId(), JSON.toJSON(command)));
            return true;
@@ -408,20 +385,13 @@
        }
    }

    public void modifyPos(Integer row, Integer bay, Integer lev) {
        BasSteService service = SpringUtils.getBean(BasSteService.class);
        if (!service.updatePos(this.slave.getId(), row, bay, lev)) {
            News.error("更新{}号穿梭车定位失败 ===>> 排：【{}】, 列：【{}】，层：【{}】", this.slave.getId(), row, bay, lev);
        }
    }

    public boolean confirmPos() {
        BasSteService service = SpringUtils.getBean(BasSteService.class);
        BasSte basSte = service.selectById(slave.getId());
        if (basSte != null) {
            // 更新plc数据块
            short[] arr = new short[] {basSte.getRow().shortValue(), basSte.getBay().shortValue(), basSte.getLev().shortValue()};
            OperateResult result = siemensS7Net.Write("V1002", arr);
            OperateResult result = siemensS7Net.Write("DB100.6", arr);
            if (result.IsSuccess) {
                // 更新数据库
                if (service.updatePakMk(this.slave.getId(), "N")) {
@@ -436,7 +406,7 @@

    public boolean modifyPosHandle(Integer row, Integer bay, Integer lev) {
        short[] arr = new short[] {row.shortValue(), bay.shortValue(), lev.shortValue()};
        OperateResult result = siemensS7Net.Write("V1002", arr);
        OperateResult result = siemensS7Net.Write("DB100.6", arr);
        if (!result.IsSuccess) {
            News.error("更新{}号穿梭车定位失败 ===>> 排：【{}】, 列：【{}】，层：【{}】", this.slave.getId(), row, bay, lev);
            return false;
@@ -451,7 +421,7 @@

    @Override
    public void close() {
//        siemensS7Net.ConnectClose();
        siemensS7Net.ConnectClose();
    }

    /**
@@ -469,61 +439,24 @@
        }
    }

//    public void modifyPos(int wrkNo, int row, int bay, int lev) {
//        BasSteService service = SpringUtils.getBean(BasSteService.class);
//        if (!service.updatePos(wrkNo,this.slave.getId(), row, bay, lev)) {
//            News.error("更新{}号穿梭车定位失败 ===>> 排：【{}】, 列：【{}】，层：【{}】", this.slave.getId(), row, bay, lev);
//        }
//    }

    /******************************************************************************************/
    /**************************************** 测试专用 *****************************************/
    /*****************************************************************************************/
    public static void main(String[] args) throws InterruptedException {
        SteSlave slave = new SteSlave();
        slave.setId(1);
        slave.setIp("192.168.2.1");
        slave.setPort(502);
        SteThread thread = new SteThread(slave);
        thread.connect();
        thread.readStatus();
        System.out.println(JSON.toJSONString(thread.steProtocol));

        // 任务作业
//    public static void main(String[] args) throws InterruptedException {
//        SteSlave slave = new SteSlave();
//        slave.setId(1);
//        slave.setIp("192.168.2.1");
//        slave.setPort(502);
//        SteThread thread = new SteThread(slave);
//        thread.connect();
//        thread.readStatus();
//        System.out.println(JSON.toJSONString(thread.steProtocol));
//
//        // 穿梭车运行禁止
//        SteCommand command = new SteCommand();
//        command.setSteNo(1); // 堆垛机编号
//        Random random = new Random();
//        int taskNo = random.nextInt(9090);
//        command.setTaskNo(taskNo); // 工作号
//        command.setTaskMode(SteTaskModeType.MOVE_LEFT); // 任务模式
////        command.setRun((short)0);
//        thread.write(command);

        // 任务完成
//        SteCommand command = new SteCommand();
//        command.setSteNo(1); // 堆垛机编号
//        command.setComplete(Boolean.TRUE); // 任务模式
//        thread.write(command);

        // 控制模式
//        SteCommand command = new SteCommand();
//        command.setControlMode((short) 1);
//        thread.write(command);

        // 复位信号
//        SteCommand command = new SteCommand();
//        command.setReset(Boolean.TRUE);
//        thread.write(command);

        // 删除指令
//        SteCommand command = new SteCommand();
//        command.setDelete(Boolean.TRUE);
//        thread.write(command);

        // 穿梭车运行禁止
        SteCommand command = new SteCommand();
        command.setRun((short)0);
        thread.write(command);

    }
//
//    }

}